Shopping Cart — Singly Linked List

The Shopping Cart as a Chain of Nodes

Each item is a node. Each node knows the next item. The cart is just the first node.

Concept + Struct

Real World Analogy

Imagine a shopping cart where items are connected with a chain. Each item has a tag (name + price + quantity) and a hook that connects to the next item. The last item's hook has nothing attached — it is NULL. You only know where the cart starts — the head pointer. From the head you can reach every item by following the hooks one at a time.

That is a singly linked list: a chain of nodes where each node has data and a pointer to the next node. You can only travel forward — head → item1 → item2 → item3 → NULL.

Memory diagram — how nodes link in RAM

Three fields in every cart node: name (the item name), price (per unit), qty (how many), and next (pointer to the next node). The cart itself is just Node *head — a single pointer to the first node. Everything else is reachable from head by following next pointers.

cart_node.c — struct definition

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ── The Node — one item in the shopping cart ── */
typedef struct Node {
    char   name[50];    /* item name e.g. "Apple"        */
    float  price;       /* price per unit e.g. 40.00     */
    int    qty;         /* quantity e.g. 2               */
    struct Node *next;  /* pointer to next item in cart  */
} Node;

/* ── The Cart — just the head pointer ── */
Node *head = NULL;   /* cart starts empty (NULL)      */

/* Create a new node on the heap */
Node* createNode(const char *name, float price, int qty) {
    Node *n = (Node*)malloc(sizeof(Node));
    strcpy(n->name, name);  /* copy name into node          */
    n->price = price;        /* set price                   */
    n->qty   = qty;          /* set quantity                */
    n->next  = NULL;        /* not yet connected           */
    return n;
}

1
typedef struct Node — names the struct and the type in one step. Now you can write Node* instead of struct Node* everywhere.
2
struct Node *next — must say struct Node inside the struct definition (not just Node) because the typedef isn't finished yet.
3
Node *head = NULL — global head pointer. NULL means the cart is empty. This is the only variable the whole cart needs.
4
malloc(sizeof(Node)) — allocates space for one node on the heap. Always check for NULL in real programs. free() this when removing nodes.

Why heap (malloc), not stack (local variable)? A local variable dies when the function returns. The cart needs to survive across multiple function calls. malloc puts the node in heap memory which lives until you explicitly free() it.

addItem() — Walk to the Last Node, Attach New Node

If cart empty → new node becomes head. Otherwise walk to end → link it.

Insert at Tail

Adding an item means creating a new node and attaching it to the end of the chain. Two cases: empty cart — new node becomes head directly. Non-empty cart — walk from head following next pointers until you reach a node whose next == NULL (the last node), then set last->next = newNode. The new node always has next = NULL because it is now the last item.

addItem() — before and after inserting "Bread"

addItem.c

/* Add item to end of cart — insert at tail */
void addItem(const char *name, float price, int qty) {

    Node *newNode = createNode(name, price, qty); /* make node */

    /* Case 1 — cart is empty: new node becomes head */
    if (head == NULL) {
        head = newNode;
        printf("  [+] '%s' added (cart was empty)\n", name);
        return;
    }

    /* Case 2 — walk to the last node */
    Node *current = head;
    while (current->next != NULL) {
        current = current->next;  /* move one step forward */
    }

    /* current is now the last node — attach new node */
    current->next = newNode;      /* link: last → new     */
    printf("  [+] '%s' added (qty:%d @ Rs%.0f)\n",
            name, qty, price);
}

/* Quick test */
int main() {
    addItem("Apple",  40.0, 2);
    addItem("Milk",   55.0, 1);
    addItem("Bread",  30.0, 3);
    return 0;
}

output

  [+] 'Apple' added (cart was empty)
  [+] 'Milk' added (qty:1 @ Rs55)
  [+] 'Bread' added (qty:3 @ Rs30)

The walk pattern while(current->next != NULL) current = current->next; is the most fundamental linked list operation. It finds the tail in O(n) time. You will use this exact pattern in almost every linked list function.

displayCart() — Walk Every Node and Print. getTotal() — Accumulate Price.

Both functions traverse the full list from head to NULL — the core linked list pattern

Traversal

Traversal is the most common linked list operation: start at head, process the current node, move to current->next, repeat until NULL. displayCart() prints each item as a receipt row. getTotal() uses the same walk but accumulates price × qty for each node into a running total and returns it.

display_total.c

/* Display all items — traverse head → NULL */
void displayCart() {
    if (head == NULL) {
        printf("  Cart is empty!\n");
        return;
    }

    printf("\n  %-20s %8s  %5s  %10s\n",
           "Item", "Price", "Qty", "Subtotal");
    printf("  %s\n", "------------------------------------------------");

    Node *current = head;             /* start at head        */

    while (current != NULL) {         /* stop when NULL       */
        float sub = current->price * current->qty;
        printf("  %-20s %8.2f  %5d  %10.2f\n",
               current->name,
               current->price,
               current->qty,
               sub);
        current = current->next;      /* move to next node    */
    }

    printf("  %s\n", "------------------------------------------------");
}

/* Calculate total — same traversal, accumulate price×qty */
float getTotal() {
    float  total   = 0.0;
    Node  *current = head;

    while (current != NULL) {
        total  += current->price * current->qty; /* accumulate */
        current = current->next;
    }
    return total;
}

/* Count items */
int countItems() {
    int   count   = 0;
    Node *current = head;
    while (current != NULL) { count++; current = current->next; }
    return count;
}

int main() {
    addItem("Apple",  40.0, 2);
    addItem("Milk",   55.0, 1);
    addItem("Bread",  30.0, 3);
    addItem("Butter", 80.0, 1);

    displayCart();
    printf("  Items  : %d\n",   countItems());
    printf("  TOTAL  : Rs %.2f\n", getTotal());
    return 0;
}

output

  Item                    Price    Qty    Subtotal
  ------------------------------------------------
  Apple                   40.00      2       80.00
  Milk                    55.00      1       55.00
  Bread                   30.00      3       90.00
  Butter                  80.00      1       80.00
  ------------------------------------------------
  Items  : 4
  TOTAL  : Rs 305.00

All three functions — displayCart, getTotal, countItems — use the exact same traversal skeleton: Node *current = head; while(current != NULL) { ...process... current = current->next; }. This pattern is so common it becomes muscle memory. The only thing that changes is what you do inside the loop.

removeItem() — Find Node, Re-link Pointers, Free Memory

Three cases: remove head / remove middle / remove tail — pointer surgery

Delete Node

Deletion is the trickiest linked list operation. You cannot delete a node by itself — you need its predecessor (previous node) to re-link the chain. Strategy: keep a prev pointer one step behind current. When current->name matches: Case 1 (head) — move head forward. Case 2 (middle/tail) — set prev->next = current->next — this bypasses the node. Then free(current) to release the memory.

removeItem("Milk") — prev→next jumps over the deleted node

removeItem.c

/* Remove item by name — three cases */
void removeItem(const char *name) {
    if (head == NULL) {
        printf("  Cart is empty.\n");
        return;
    }

    Node *current = head;
    Node *prev    = NULL;   /* tracks the node BEFORE current */

    /* Walk until we find the name or reach end */
    while (current != NULL &&
           strcmp(current->name, name) != 0) {
        prev    = current;         /* prev follows one behind      */
        current = current->next;  /* current moves forward        */
    }

    /* Not found */
    if (current == NULL) {
        printf("  '%s' not in cart.\n", name);
        return;
    }

    /* Case 1 — deleting the head node */
    if (prev == NULL) {
        head = current->next;     /* head moves to next node      */
    }
    /* Case 2 — deleting middle or tail node */
    else {
        prev->next = current->next; /* bypass current node          */
    }

    printf("  [-] '%s' removed from cart.\n", current->name);
    free(current);               /* release memory — never skip! */
}

int main() {
    addItem("Apple",  40.0, 2);
    addItem("Milk",   55.0, 1);
    addItem("Bread",  30.0, 3);

    printf("Before removal:\n");
    displayCart();

    removeItem("Milk");         /* remove middle node */
    removeItem("Apple");        /* remove head node   */
    removeItem("Eggs");         /* not in cart        */

    printf("After removals:\n");
    displayCart();
    printf("  TOTAL: Rs %.2f\n", getTotal());
    return 0;
}

output

Before removal:
  Item                    Price    Qty    Subtotal
  ------------------------------------------------
  Apple                   40.00      2       80.00
  Milk                    55.00      1       55.00
  Bread                   30.00      3       90.00
  ------------------------------------------------
  [-] 'Milk' removed from cart.
  [-] 'Apple' removed from cart.
  'Eggs' not in cart.
After removals:
  Item                    Price    Qty    Subtotal
  ------------------------------------------------
  Bread                   30.00      3       90.00
  ------------------------------------------------
  TOTAL: Rs 90.00

Always free(current) after removal. If you re-link pointers but skip free(), the node still occupies heap memory — a memory leak. In a long-running program, leaked nodes accumulate and eventually crash the program. Every malloc must have a matching free.

All Functions Together — Menu-Driven Complete Program

Add · Remove · Display · Total · Clear · all functions in one runnable file

Full Project

The complete program assembles all five functions plus a clearCart() that frees every node in sequence — walking the list and freeing one node at a time. A do-while menu loop keeps the program running until the user chooses Exit. This is a complete, compilable, fully working C program demonstrating every core singly linked list operation.

Function	What it does	Key pointer operation
createNode()	malloc a new node, fill fields, return pointer	`malloc(sizeof(Node))`
addItem()	Walk to tail, set `tail->next = newNode`	Insert at tail
displayCart()	Traverse head→NULL, print each node	`current = current->next`
getTotal()	Traverse, accumulate price×qty	Same traversal
countItems()	Traverse, count++ each node	Same traversal
removeItem()	Find node, bypass with prev->next, free node	`prev->next = current->next; free(current)`
clearCart()	Free every node one by one	`tmp=current->next; free(current); current=tmp`

shopping_cart_complete.c

C — Complete Project

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* ══════════════════════════════════════
   NODE DEFINITION
═══════════════════════════════════════ */
typedef struct Node {
    char   name[50];
    float  price;
    int    qty;
    struct Node *next;
} Node;

Node *head = NULL;   /* global head — empty cart */

/* ══════════════════════════════════════
   CREATE NODE
═══════════════════════════════════════ */
Node* createNode(const char *name, float price, int qty) {
    Node *n   = (Node*)malloc(sizeof(Node));
    strcpy(n->name, name);
    n->price  = price;
    n->qty    = qty;
    n->next   = NULL;
    return n;
}

/* ══════════════════════════════════════
   ADD ITEM — insert at tail
═══════════════════════════════════════ */
void addItem(const char *name, float price, int qty) {
    Node *newNode = createNode(name, price, qty);
    if (head == NULL) { head = newNode; }
    else {
        Node *curr = head;
        while (curr->next != NULL) curr = curr->next;
        curr->next = newNode;
    }
    printf("  [+] '%s' added (qty:%d @ Rs%.2f)\n", name, qty, price);
}

/* ══════════════════════════════════════
   DISPLAY CART — traverse & print
═══════════════════════════════════════ */
void displayCart() {
    if (head == NULL) { printf("  Cart is empty.\n"); return; }
    printf("\n  %-20s %8s %5s %10s\n","Item","Price","Qty","Subtotal");
    printf("  %-50s\n", "--------------------------------------------------");
    Node *curr = head;
    while (curr != NULL) {
        printf("  %-20s %8.2f %5d %10.2f\n",
               curr->name, curr->price, curr->qty,
               curr->price * curr->qty);
        curr = curr->next;
    }
    printf("  %-50s\n", "--------------------------------------------------");
}

/* ══════════════════════════════════════
   GET TOTAL
═══════════════════════════════════════ */
float getTotal() {
    float total = 0.0;
    Node *curr  = head;
    while (curr != NULL) { total += curr->price * curr->qty; curr = curr->next; }
    return total;
}

/* ══════════════════════════════════════
   REMOVE ITEM — find, bypass, free
═══════════════════════════════════════ */
void removeItem(const char *name) {
    Node *curr = head, *prev = NULL;
    while (curr != NULL && strcmp(curr->name, name) != 0) {
        prev = curr; curr = curr->next;
    }
    if (curr == NULL) { printf("  '%s' not in cart.\n", name); return; }
    if (prev == NULL) head = curr->next;  /* was head node   */
    else              prev->next = curr->next; /* middle/tail  */
    printf("  [-] '%s' removed. (was Rs%.2f × %d)\n",
           curr->name, curr->price, curr->qty);
    free(curr);
}

/* ══════════════════════════════════════
   CLEAR CART — free all nodes
═══════════════════════════════════════ */
void clearCart() {
    Node *curr = head;
    while (curr != NULL) {
        Node *tmp = curr->next;  /* save next BEFORE freeing    */
        free(curr);               /* free current node           */
        curr = tmp;               /* move to saved next          */
    }
    head = NULL;
    printf("  Cart cleared.\n");
}

/* ══════════════════════════════════════
   MENU
═══════════════════════════════════════ */
void printMenu() {
    printf("\n  ╔══════════════════════════╗\n");
    printf("  ║   🛒  SHOPPING CART     ║\n");
    printf("  ╠══════════════════════════╣\n");
    printf("  ║  1. Add Item             ║\n");
    printf("  ║  2. Remove Item          ║\n");
    printf("  ║  3. View Cart            ║\n");
    printf("  ║  4. Get Total            ║\n");
    printf("  ║  5. Clear Cart           ║\n");
    printf("  ║  6. Exit                 ║\n");
    printf("  ╚══════════════════════════╝\n");
    printf("  Choice: ");
}

/* ══════════════════════════════════════
   MAIN
═══════════════════════════════════════ */
int main() {
    int   choice;
    char  name[50];
    float price;
    int   qty;

    /* Pre-load some items */
    addItem("Apple",  40.0, 2);
    addItem("Milk",   55.0, 1);
    addItem("Bread",  30.0, 3);

    do {
        printMenu();
        scanf("%d", &choice);
        getchar();  /* flush newline */

        switch (choice) {
            case 1:
                printf("  Name: ");  fgets(name, 50, stdin);
                name[strcspn(name, "\n")] = 0; /* remove newline */
                printf("  Price: "); scanf("%f", &price);
                printf("  Qty  : "); scanf("%d", &qty);
                getchar();
                addItem(name, price, qty);
                break;
            case 2:
                printf("  Remove item name: ");
                fgets(name, 50, stdin);
                name[strcspn(name, "\n")] = 0;
                removeItem(name);
                break;
            case 3:
                displayCart();
                break;
            case 4:
                displayCart();
                printf("  TOTAL: Rs %.2f\n", getTotal());
                break;
            case 5:
                clearCart();
                break;
            case 6:
                clearCart();  /* always free before exit */
                printf("  Goodbye! 🛒\n");
                break;
            default:
                printf("  Invalid choice.\n");
        }
    } while (choice != 6);

    return 0;
}

sample run

  [+] 'Apple' added (qty:2 @ Rs40.00)
  [+] 'Milk' added (qty:1 @ Rs55.00)
  [+] 'Bread' added (qty:3 @ Rs30.00)

  ╔══════════════════════════╗
  ║   🛒  SHOPPING CART     ║
  ╠══════════════════════════╣
  ║  1. Add Item             ║
  ║  2. Remove Item          ║
  ║  3. View Cart            ║
  ║  4. Get Total            ║
  ║  5. Clear Cart           ║
  ║  6. Exit                 ║
  ╚══════════════════════════╝
  Choice: 4

  Item                    Price   Qty    Subtotal
  --------------------------------------------------
  Apple                   40.00     2       80.00
  Milk                    55.00     1       55.00
  Bread                   30.00     3       90.00
  --------------------------------------------------
  TOTAL: Rs 305.00

  Choice: 2
  Remove item name: Milk
  [-] 'Milk' removed. (was Rs55.00 × 1)

  Choice: 4
  Item                    Price   Qty    Subtotal
  --------------------------------------------------
  Apple                   40.00     2       80.00
  Bread                   30.00     3       90.00
  --------------------------------------------------
  TOTAL: Rs 170.00

  Choice: 6
  Cart cleared.
  Goodbye! 🛒

clearCart() pattern: Node *tmp = curr->next; free(curr); curr = tmp; — you must save next before freeing, because after free(curr) the memory is gone and reading curr->next is undefined behaviour. Save next first, then free, then move.

checklist — tick each concept when understood

Node struct: name, price, qty, struct Node *next. Must use struct Node inside the struct. typedef lets you write Node* everywhere else. head = NULL means empty cart.
createNode / malloc: malloc(sizeof(Node)) allocates heap memory for one node. Heap memory survives across function calls. Must be free()'d eventually or it leaks.
addItem() — insert at tail: If head==NULL → new node is head. Else walk: while(curr->next != NULL) curr = curr->next; then curr->next = newNode.
Traversal pattern: Node *curr = head; while(curr != NULL) { ...process... curr = curr->next; } — used by displayCart, getTotal, countItems, clearCart. The single most important linked list pattern.
removeItem() — prev pointer: Keep prev one step behind current. When found: if prev==NULL → deleting head → head = curr->next. Else prev->next = curr->next. Then free(curr).
clearCart() — save next before free: Node *tmp = curr->next; free(curr); curr = tmp; — never access curr->next after free(curr) — undefined behaviour.
Arrow operator (->): curr->name is shorthand for (*curr).name. When you have a pointer to a struct, use -> to access its fields.

🛒 Shopping CartSingly Linked List

🛒 Shopping Cart
Singly Linked List