Introduction to Programming in C

📘 Linked Lists in C (Singly, Doubly, Circular)

A linked list is a linear data structure where elements (nodes) are connected using pointers. Unlike arrays, linked lists are dynamic in nature and allow efficient insertions and deletions.

🔹 What is a Node?

Each node typically contains:

• Data: The actual value
• Pointer: A reference to the next (or previous) node

struct Node {
  int data;
  struct Node* next;
};

🔸 Singly Linked List

Each node points to the next node. The last node's pointer is NULL.

struct Node {
  int data;
  struct Node* next;
};

// Create a new node
struct Node* createNode(int value) {
  struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
  newNode->data = value;
  newNode->next = NULL;
  return newNode;
}

You can build a list by connecting multiple nodes using next.

🔁 Traversing a Singly Linked List

void traverse(struct Node* head) {
  struct Node* temp = head;
  while (temp != NULL) {
    printf("%d -> ", temp->data);
    temp = temp->next;
  }
  printf("NULL\n");
}

🔄 Doubly Linked List

In a doubly linked list, each node has two pointers — one to the next node and one to the previous node.

struct DNode {
  int data;
  struct DNode* prev;
  struct DNode* next;
};

• Allows traversal in both directions
• More memory consumption due to two pointers

🔃 Circular Linked List

In a circular linked list, the last node points back to the first node, forming a loop.

void makeCircular(struct Node* tail, struct Node* head) {
  tail->next = head;
}

You can have both singly and doubly circular linked lists. Useful in applications like round-robin scheduling or media players.

📚 UdaanPath Example: Student Record System

At UdaanPath, imagine you’re storing students dynamically for a scholarship program:

struct Student {
  int id;
  char name[50];
  struct Student* next;
};

You can add/remove students in constant time using head/tail pointers and linked list functions.

🧠 Benefits of Linked Lists

• Efficient insertion and deletion (especially in middle)
• No fixed size; uses dynamic memory
• Suitable for implementing stacks, queues, graphs, etc.

⚠️ Drawbacks

• Slower access (no random access like arrays)
• More memory overhead due to pointers
• Prone to segmentation faults if not handled carefully

📝 Practice Tasks

1. Create a singly linked list with insert and delete functions
2. Write a function to reverse a singly linked list
3. Implement a doubly linked list traversal
4. Create a circular list and detect loops

✅ Summary

• Linked lists are dynamic structures using pointers
• Singly, doubly, and circular lists serve different use cases
• Efficient in memory reallocation, insertion, and deletion

🚀 Coming Next

Next, we’ll implement Stacks and Queues using Arrays and Linked Lists — essential for understanding runtime logic, recursion, and memory usage in C.