C Programming and Data Structures Semester Study Guide: From Syntax to Trees

Build C and data structures in dependency order, then test each idea through exact program, memory, stack, queue, tree and complexity traces.

KnowledgeGate Team

Exam prep & CS education

Updated 8 Nov 20266 min read
C Programming and Data Structures Semester Study Guide: From Syntax to Trees

A semester can ask you to write C on paper, run programs in the lab, and explain pointers in a viva. Put these topics in dependency order: expressions and control flow, functions, arrays and addresses, linked nodes, stacks and queues, trees, then complexity. Examples use marks = {18, 7, 24, 12, 31} and a BST built from 40, 25, 60, 10, 30, 50, 70.

See the broader CS Fundamentals study hub.

For a C-only treatment of language rules, use C Programming by Yash Sir: Complete Guide with Worked Examples; this semester path uses C as the bridge into linked structures, stacks, queues and trees.

1. Build the semester map in dependency order

Study in prerequisite order: data types, expressions and branches support loops; loops and functions support arrays; addresses and dynamic allocation support linked structures; linear structures lead to tree traversals; counting operations explains complexity.

Check each layer: predict that 7 / 2 is 3 for integer operands; trace all five loop iterations; explain why changing the caller's int needs its address; draw data and next; contrast stack and queue removal order; state that smaller BST keys go left; count iterations before writing Big-O.

Match this dependency order to your current syllabus.

2. C syntax and functions: make one small program do real work

A small counting function makes the syntax, parameter passing and loop state concrete:

c
#include <stdio.h>

int count_above(const int a[], int n, int threshold) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] > threshold) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int marks[5] = {18, 7, 24, 12, 31};
    printf("%d\n", count_above(marks, 5, 15));
    return 0;
}

Trace all five iterations before compiling:

i

Test

Count after the test

0

18 > 15, true

1

1

7 > 15, false

1

2

24 > 15, true

2

3

12 > 15, false

2

4

31 > 15, true

3

The function returns and prints exactly 3. const int a[] prevents changes through a; n supplies the length because the parameter does not carry it. Use C Language: Concepts, MCQs, Coding Questions for focused syntax, function and coding practice.

3. Pointers and memory: addresses explain what syntax hides

Assume for this illustration that sizeof(int) = 4 bytes and &marks[0] = 1000. Elements begin at 1000, 1004, 1008, 1012 and 1016. If int *p = marks + 2, then p = 1008, *p = 24, and *(p + 2) = 31 at address 1016. These addresses are not guaranteed at runtime.

In count_above(marks, 5, 15), the array decays to its first element's address, so a receives 1000. The array owns five elements; a pointer stores an address.

C passes pointer values by value, but dereferencing them can change caller-owned values. Start with x = 12 and y = 31. In swap(&x, &y), temp = 12; the first write makes x = 31, and the second makes y = 12. Passing plain x and y would change only copies. The A separate pointer-and-array deep dive covers pointer arithmetic and precedence.

Diagram of five int cells with values 18, 7, 24, 12 and 31 at addresses 1000 through 1016; count_above receives the base address and returns 3.

4. Arrays, linked lists, stacks and queues: choose by the operation

Representation controls operation costs. In [18, 7, 24, 12, 31], index 2 returns 24. With spare capacity, inserting 9 at index 1 shifts 31, 12, 24 and 7 right, producing [18, 9, 7, 24, 12, 31]. In 12 -> 7 -> 24, inserting 18 after 7 produces 12 -> 7 -> 18 -> 24; deleting the head produces 7 -> 18 -> 24.

A stack is last-in-first-out: [], push(4) gives [4], push(7) gives [4,7], and push(9) gives [4,7,9]. Then pop() returns 9 and leaves [4,7]; top() returns 7.

For a capacity-5 circular queue, track front and size. Enqueue 10,20,30 into cells 0,1,2. Dequeue returns 10, giving front=1,size=2. Enqueue 40,50,60 into cells 3,4,0. After wrapping, the logical sequence is [20,30,40,50,60], with front=1,size=5.

Name the invariant before choosing an implementation.

5. Trees: one BST can carry insert, search and traversal

Insert 40, 25, 60, 10, 30, 50, 70 in that order. The root is 40. Its left child 25 has children 10 and 30; its right child 60 has children 50 and 70.

The four traversals are:

  • Preorder: 40, 25, 10, 30, 60, 50, 70

  • Inorder: 10, 25, 30, 40, 50, 60, 70

  • Postorder: 10, 30, 25, 50, 70, 60, 40

  • Level order: 40, 25, 60, 10, 30, 50, 70

Searching for 50 compares 40, moves right to 60, then left to 50: exactly three node visits. Inorder is sorted because the BST rule holds; an arbitrary binary tree need not be ordered. Continue with Binary trees and binary search trees: traversals, operations, and the exam angle for deletion and balancing.

Binary search tree rooted at 40 with children 25 and 60, traversal orders listed beside it, and the highlighted path 40 to 60 to 50.

6. Complexity basics: count the work before choosing notation

For for (i = 1; i <= 64; i *= 2), the body runs at i = 1, 2, 4, 8, 16, 32, 64, exactly seven times. Then i = 128 fails the condition. Doubling is logarithmic, but O(log n) is a growth bound, not an exact count.

Linear search for 31 in [18, 7, 24, 12, 31] checks all five values. Binary search for 31 in sorted [7, 12, 18, 24, 31], using the lower middle index, checks 18, then 24, then 31: three comparisons. Binary search requires sorted data.

Operation

Complexity

Assumption

Array access by index

O(1)

Valid index

Linked-list access by position

O(n)

Traverse from a known end

Stack push or pop

O(1)

Top maintained

Queue enqueue or dequeue

O(1)

Indices maintained

BST search

Average O(log n), worst O(n)

A skewed insertion order can form a chain

Count operations before choosing notation and state its assumptions.

7. Prepare one concept for the written paper, coding lab and viva

Use count_above three ways. On paper, trace five rows and reach 3. In the lab, test thresholds 15, 31 and 6; the outputs are 3, 0 and 5. In the viva, explain that > excludes the threshold, n is separate because an array parameter loses its length, and const int a[] receives an address.

Pair each mistake with its cause and correction:

  • i <= n reads past the last valid index because a length-5 array ends at index 4. Use i < n.

  • Dereferencing a freed node has undefined behaviour because its lifetime has ended. Update links before free, then never use the old pointer.

  • Popping an empty stack violates the operation's precondition. Test emptiness first.

  • Calling every BST search logarithmic ignores a skewed tree. State both average and worst cases.

Confirm unit coverage, paper details, compiler requirements, lab rules and viva instructions in the official syllabus, lab sheet and college notices. Build your checklist from them.

8. The short version and the next study step

Control flow drives functions; functions process arrays; pointers expose addresses; links build dynamic structures; invariants distinguish structures; operation counts lead to complexity. count_above({18,7,24,12,31}, 5, 15) returns 3, while searching for 50 in the BST visits 40 -> 60 -> 50.

Use the Data Structures course to continue across linear and non-linear structures, or revisit the C Language course for syntax, functions and pointers. Redraw both diagrams and reproduce every trace without notes.