ULTIMATE DATA STRUCTURES NOTES

📚 TABLE OF CONTENTS
1. Prerequisites
Functions

Recursion
Arrays

Pointers
Structures

2. Introduction to Data Structures

What are Data Structures?

Abstract Data Types (ADT)

Types of Data Structures

Operations on Data Structures

3. Stack
Stack as ADT
Array Implementation of Stack

Multiple Stacks

4. Queue
Queue as ADT
Array Implementation of Queue
Circular Queue
 Priority Queue
Double Ended Queue (Deque)

Multiple Queues

5. Linked List
Concept of Linked List vs Array
Singly Linked List
Doubly Linked List

Circular Linked List

Stack Using Linked List

Queue Using Linked List

Reversing a Linked List

6. Tree
Tree Concepts and Terms
Binary Tree

Binary Tree Traversals

Binary Search Tree (BST)

7. Applications of Data Structures

Stack Applications
Trees Applications

8. Summary of Key Concepts

<a id="prerequisites"></a>

0. PREREQUISITES
<a id="functions"></a>

Functions
What are functions?
Functions are blocks of code that perform specific tasks. They help us organize our program into
reusable pieces.

Key Characteristics of Functions:

Reusability: Write once, use many times

Modularity: Break complex programs into manageable pieces

Abstraction: Hide implementation details from the user

Example:

// This function adds two numbers and returns the sum

int add(int a, int b) {
return a + b; // Returns the sum of a and b
}

// This is how you call the function

int result = add(5, 3); // result will be 8

Algorithm Explanation:

1. Function add takes two integer parameters a and b

2. It calculates their sum and returns the result

3. When calling the function with values 5 and 3, it returns 8

<a id="recursion"></a>

Recursion
What is recursion?
When a function calls itself to solve a problem. It breaks a problem into smaller versions of the same
problem.

Key Characteristics of Recursion:

Base Case: A condition that stops the recursion

Recursive Case: The function calls itself with a simpler version of the problem

Call Stack: Each recursive call is added to the call stack

Example: Calculating factorial

// Function to calculate factorial using recursion

int factorial(int n) {
if (n <= 1) { // Base case: factorial of 0 or 1 is 1
return 1;
} else {
return n * factorial(n-1); // Function calls itself with smaller value
}
}

// Usage: factorial(5) = 5 * 4 * 3 * 2 * 1 = 120

Algorithm Explanation:

1. Check if n is 0 or 1 (base case)

 2. If true, return 1 (factorial of 0 or 1 is 1)

3. Otherwise, return n * factorial(n-1) (recursive case)

4. For factorial(5):
factorial(5) = 5 * factorial(4)

factorial(4) = 4 * factorial(3)

factorial(3) = 3 * factorial(2)

factorial(2) = 2 * factorial(1)

factorial(1) = 1 (base case reached)

Then unwind: 21 = 2, 32 = 6, 46 = 24, 524 = 120

<a id="arrays"></a>

Arrays
What are arrays?
Collections of similar data items stored at contiguous memory locations.

Key Characteristics of Arrays:

Fixed Size: Size is defined at declaration

Homogeneous Elements: All elements must be of the same data type

Random Access: Can access any element directly using its index

Zero-based Indexing: First element is at index 0

Example:
 c

// Declaring and initializing an array

int marks[5] = {85, 75, 90, 67, 82}; // Array of 5 integers

// Accessing array elements

printf("First mark: %d\n", marks[0]); // Arrays start at index 0
printf("Third mark: %d\n", marks[2]); // Access the third element

// Modifying array elements

marks[1] = 95; // Change the second element to 95

Algorithm for Array Operations:

1. Declaration: Allocate contiguous memory for fixed number of elements

2. Access: Calculate address using base address + (index * size of data type)

3. Modification: Direct access to memory location to change value

<a id="pointers"></a>

Pointers (Basic Introduction)

What are pointers?
Variables that store memory addresses of other variables.

Key Characteristics of Pointers:

Address Storage: Store memory addresses, not actual values

Indirection: Access values indirectly through memory addresses

Dynamic Memory: Enable dynamic memory allocation and deallocation

Efficient Parameter Passing: Pass references instead of copying large data

Simple Example:

int number = 10; // Regular integer variable

int *ptr = &number; // Pointer storing address of 'number'

printf("Value: %d\n", number); // Prints: 10

printf("Value using pointer: %d\n", *ptr); // Prints: 10 (dereferencing)

Algorithm for Pointer Operations:

1. Declaration: Create a pointer variable of specific type

2. Assignment: Store address of a variable using & operator

3. Dereferencing: Access value at the address using * operator

<a id="structures"></a>

Structures
What are structures?
User-defined data types that allow storing different types of data items together.

Key Characteristics of Structures:

Heterogeneous Elements: Can store different data types together

Related Data Grouping: Group related data under a single name

Memory Allocation: Contiguous memory allocation for all members

Member Access: Use dot (.) operator to access members

Example:
 c

// Define a structure for a student

struct Student {
char name[50]; // Character array for name
int roll_no; // Integer for roll number
float marks; // Float for marks
};

// Creating and using a structure variable

struct Student s1 = {"Alice", 101, 85.5}; // Initialize all members

printf("Name: %s\n", s1.name); // Access using dot operator

printf("Roll No: %d\n", s1.roll_no);

Algorithm for Structure Operations:

1. Definition: Define structure template with members of different types

2. Declaration: Create variables of the structure type

3. Initialization: Assign values to structure members

4. Access: Use dot operator to access individual members

📝 Prerequisites: Oral Exam Questions

1. Functions
What are functions and why are they important in programming?
Explain the difference between function declaration and function definition.

What is the purpose of the return statement in a function?

What is function overloading? Does C support it?
 What are the advantages of using functions in a program?

2. Recursion
What is recursion and how does it differ from iteration?
What are the essential components of a recursive function?

What are the advantages and disadvantages of recursion?

Explain how the factorial function works recursively.

How does the call stack work during recursive function calls?

What is stack overflow in the context of recursion?

3. Arrays
What is an array? How is memory allocated for arrays?
Why is index 0 used for the first element in an array?

What are the limitations of arrays in C?

How are multi-dimensional arrays stored in memory?

What is the difference between declaration and initialization of an array?

4. Pointers
What is a pointer and what does it contain?

What is the difference between & and * operators regarding pointers?

What is dereferencing? How do you dereference a pointer?

Why are pointers useful in C programming?

What is a null pointer and when would you use it?

5. Structures
What is a structure in C? How does it differ from an array?
How do you access members of a structure?
 Can structures contain other structures? Explain.

What is the difference between a structure and a union?

Why would you use structures in a program?

<a id="introduction"></a>

I. INTRODUCTION
<a id="what-are-data-structures"></a>

What are Data Structures?

Definition: Data structures are specialized formats for organizing, processing, retrieving and storing
data in a computer.

Think of it like: If data is like items, then data structures are like different types of containers to store
these items - each with its own way of adding, removing, and accessing items.

Importance of Data Structures:

Efficiency: Proper data structures can make algorithms more efficient

Organization: Help organize and manage large amounts of data

Problem Solving: Different problems require different data organization techniques

Memory Utilization: Optimize memory usage for specific applications

<a id="abstract-data-types-adt"></a>

Abstract Data Types (ADT)

Definition: An ADT is a mathematical model for data structures, defined by its behavior from the
user's perspective.
Real-life example: Think of a TV remote. You know what buttons do what functions (interface), but
you don't need to know the electronic circuitry inside (implementation) to use it.

Key Characteristics of ADTs:

Abstraction: Hide implementation details from the user

Operations: Define operations that can be performed

Data: Define the data to be stored

Interface: Provide clear interface for interactions

Common ADTs include:

Stack (Last-In-First-Out)
Queue (First-In-First-Out)

List
Tree

<a id="types-of-data-structures"></a>

Types of Data Structures

1. Linear vs Nonlinear:

Linear: Elements form a sequence

Arrays, Linked Lists, Stacks, Queues

Each element has at most one predecessor and one successor

Elements can be traversed sequentially

Nonlinear: Elements don't form a sequence

Trees, Graphs
 Elements can have multiple predecessors and successors
Multiple paths between elements

2. Static vs Dynamic:

Static: Fixed size, allocated at compile time

Arrays

Size cannot be changed during execution

Memory allocated once

Dynamic: Size can change during program execution

Linked Lists, Dynamic Arrays

Can grow or shrink as needed

Memory allocated and deallocated during runtime

3. Primitive vs Non-Primitive:

Primitive: Basic data types built into a language

Integer, Float, Character, Boolean

Directly operated upon by machine instructions

Non-Primitive: Derived from primitive data types

Arrays, Lists, Stacks, Queues, Trees, Graphs
More complex operations and structures

<a id="operations-on-data-structures"></a>

Operations on Data Structures

Common operations include:
 Insertion: Adding a new element
Can be at the beginning, end, or specific position

May require reorganization of existing elements

Deletion: Removing an element

Can be from beginning, end, or specific position
May require reorganization of remaining elements

Traversal: Accessing each element exactly once

Sequential visit of all elements
Used for operations like printing, searching, etc.

Searching: Finding a specific element

Linear search, binary search, etc.

Efficiency depends on data structure organization

Sorting: Arranging elements in a particular order

Ascending, descending, or custom order

Various algorithms like bubble sort, quick sort, etc.

Merging: Combining two or more data structures

Splitting: Dividing a data structure into parts

📝 Introduction to Data Structures: Oral Exam Questions

1. What are data structures and why are they important in computer science?
2. Differentiate between data structures and abstract data types.

3. Give real-world examples for abstract data types.

4. What is the difference between linear and non-linear data structures? Give examples of each.
 5. Explain the difference between static and dynamic data structures with examples.

6. What factors should be considered when choosing a data structure for a specific problem?

7. How does memory allocation differ between static and dynamic data structures?
8. Describe the common operations that can be performed on data structures.

9. What is traversal and why is it important in data structures?

10. How do primitive data structures differ from non-primitive data structures?
11. What is the relationship between algorithms and data structures?

12. Explain how efficiency of operations varies across different data structures.

<a id="stack"></a>

II. STACK
<a id="stack-as-adt"></a>

Stack as ADT
Definition: A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle.

Real-life example: Think of a stack of plates. You can only take the top plate (last one placed), not
any from the middle.

Key Principles of Stack:

LIFO (Last-In-First-Out): The last element added is the first one to be removed

Restricted Access: Elements can only be added or removed from one end (top)

Sequential Access: Elements are accessed in reverse order of their addition

Basic Operations:
 Push: Add an element to the top

Pop: Remove the top element

Peek/Top: View the top element without removing it

IsEmpty: Check if stack is empty

IsFull: Check if stack is full (for array implementation)

Visual Representation:

│ │
│ C │ ← Top (most recently added)
│ B │
│ A │ ← Bottom (least recently added)
└───────┘

<a id="array-implementation-of-stack"></a>

Array Implementation of Stack

c
#include <stdio.h>
#define MAX 5 // Maximum size of stack

// Global variables
int stack[MAX]; // Array to store the stack elements
int top = -1; // Index of top element, -1 means empty stack

// Function to check if stack is full

int isFull() {
if (top == MAX - 1) { // If top is at the last index
return 1; // Return true (stack is full)
} else {
return 0; // Return false (stack is not full)
}
}

// Function to check if stack is empty

int isEmpty() {
if (top == -1) { // If top is -1
return 1; // Return true (stack is empty)
} else {
return 0; // Return false (stack is not empty)
}
}

// Function to add an element to the stack

void push(int item) {
if (isFull()) { // Check if stack is full
printf("Stack Overflow\n"); // Print error message
} else {
top++; // Increment top
stack[top] = item; // Place the item at top position
 printf("%d pushed to stack\n", item);
}
}

// Function to remove an element from the stack

int pop() {
if (isEmpty()) { // Check if stack is empty
printf("Stack Underflow\n"); // Print error message
return -1; // Return error value
} else {
int item = stack[top]; // Get the top item
top--; // Decrement top
return item; // Return the item
}
}

// Function to view the top element without removing it

int peek() {
if (isEmpty()) { // Check if stack is empty
printf("Stack is empty\n"); // Print error message
return -1; // Return error value
} else {
return stack[top]; // Return the top item
}
}

// Sample usage
int main() {
push(10); // Add 10 to stack
push(20); // Add 20 to stack
push(30); // Add 30 to stack
printf("Top element: %d\n", peek()); // Should print 30
 printf("Popped: %d\n", pop()); // Should print 30
printf("Popped: %d\n", pop()); // Should print 20
printf("Top element after pops: %d\n", peek()); // Should print 10
return 0;
}

Algorithm Explanation for Stack Operations:

1. Initialization:
Create an array of fixed size (MAX)
Initialize top = -1 (indicating empty stack)

2. isFull() Operation:
Check if top == MAX-1
If true, stack is full, return 1

Otherwise, return 0

3. isEmpty() Operation:
Check if top == -1

If true, stack is empty, return 1

Otherwise, return 0

4. push() Operation:
Check if stack is full using isFull()
If full, print "Stack Overflow"

Otherwise:
Increment top

Place the new item at stack[top]

 5. pop() Operation:
Check if stack is empty using isEmpty()

If empty, print "Stack Underflow" and return error value (-1)

Otherwise:
Store the value at stack[top] in a variable
Decrement top
Return the stored value

6. peek() Operation:
Check if stack is empty using isEmpty()

If empty, print "Stack is empty" and return error value (-1)

Otherwise, return the value at stack[top] without changing top

<a id="multiple-stacks"></a>

Multiple Stacks
Multiple stacks can be implemented in a single array by:

1. Dividing the array into fixed sections:

Allocate specific sections of the array for each stack

Each stack has its own top pointer

Simple but less memory efficient if stacks grow unevenly

2. Starting stacks from opposite ends of the array and growing towards the middle:
For two stacks, first stack grows from left to right

Second stack grows from right to left

Stacks are full when they meet in the middle

 More efficient use of memory

Visual Representation of Two Stacks in One Array:

[0][1][2][3][4][5][6][7][8][9]
↑ ↑
top1 top2

📝 Stack: Oral Exam Questions

1. What is a stack data structure and what is its fundamental principle?
2. Explain the LIFO (Last-In-First-Out) property with an example.
3. List and explain the basic operations that can be performed on a stack.

4. What are the applications of stack in computer science?

5. What happens when you try to pop an element from an empty stack?

6. What happens when you try to push an element into a full stack?
7. How is a stack implemented using an array? What are the limitations of this implementation?

8. What is the time complexity of push, pop, and peek operations in a stack?
9. What are the advantages and disadvantages of implementing a stack using an array?

10. How can multiple stacks be implemented in a single array?

11. Compare the fixed partition and flexible partition methods for implementing multiple stacks.
12. What is stack overflow and stack underflow? When do they occur?

13. How does the call stack work in programming languages?

14. How is memory managed in a stack implementation?
15. How can a stack be implemented without using an array?
<a id="queue"></a>

III. QUEUE
<a id="queue-as-adt"></a>

Queue as ADT
Definition: A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle.

Real-life example: Think of people standing in line for movie tickets. The person who came first gets
served first.

Key Principles of Queue:

FIFO (First-In-First-Out): The first element added is the first one to be removed

Two Ends: Elements are added at one end (rear) and removed from the other end (front)

Sequential Processing: Processing in the exact order of arrival

Basic Operations:

Enqueue: Add an element to the rear/back

Dequeue: Remove an element from the front

Front: Get the front element without removing

IsEmpty: Check if queue is empty

IsFull: Check if queue is full

Visual Representation:
 Front Rear
↓ ↓
[A][B][C][D][ ][ ][ ][ ]

<a id="array-implementation-of-queue"></a>

Array Implementation of Queue

c
#include <stdio.h>
#define MAX 5 // Maximum size of queue

// Global variables
int queue[MAX]; // Array to store queue elements
int front = -1; // Index of front element
int rear = -1; // Index of rear element

// Function to check if queue is full

int isFull() {
if (rear == MAX - 1) { // If rear is at the last index
return 1; // Return true (queue is full)
} else {
return 0; // Return false (queue is not full)
}
}

// Function to check if queue is empty

int isEmpty() {
if (front == -1 || front > rear) { // If front is -1 or has crossed rear
return 1; // Return true (queue is empty)
} else {
return 0; // Return false (queue is not empty)
}
}

// Function to add an element to the queue

void enqueue(int item) {
if (isFull()) { // Check if queue is full
printf("Queue Overflow\n"); // Print error message
} else {
if (front == -1) { // If queue was empty
 front = 0; // Set front to the first position
}
rear++; // Increment rear
queue[rear] = item; // Place the item at rear position
printf("%d enqueued to queue\n", item);
}
}

// Function to remove an element from the queue

int dequeue() {
if (isEmpty()) { // Check if queue is empty
printf("Queue Underflow\n"); // Print error message
return -1; // Return error value
} else {
int item = queue[front]; // Get the front item
front++; // Increment front
if (front > rear) { // If the last item was dequeued
front = rear = -1; // Reset front and rear
}
return item; // Return the item
}
}

// Function to get the front element without removing it

int getFront() {
if (isEmpty()) { // Check if queue is empty
printf("Queue is empty\n"); // Print error message
return -1; // Return error value
} else {
return queue[front]; // Return the front item
}
}
 // Sample usage
int main() {
enqueue(10); // Add 10 to queue
enqueue(20); // Add 20 to queue
enqueue(30); // Add 30 to queue
printf("Front element: %d\n", getFront()); // Should print 10
printf("Dequeued: %d\n", dequeue()); // Should print 10
printf("Dequeued: %d\n", dequeue()); // Should print 20
printf("Front element after dequeues: %d\n", getFront()); // Should print 30
return 0;
}

Algorithm Explanation for Queue Operations:

1. Initialization:
Create an array of fixed size (MAX)
Initialize front = -1 and rear = -1 (indicating empty queue)

2. isFull() Operation:
Check if rear == MAX-1
If true, queue is full, return 1

Otherwise, return 0

3. isEmpty() Operation:
Check if front == -1 OR front > rear

If true, queue is empty, return 1

Otherwise, return 0

4. enqueue() Operation:
 Check if queue is full using isFull()

If full, print "Queue Overflow"

Otherwise:
If front == -1, set front = 0 (first element)

Increment rear
Place the new item at queue[rear]

5. dequeue() Operation:
Check if queue is empty using isEmpty()
If empty, print "Queue Underflow" and return error value (-1)

Otherwise:
Store the value at queue[front] in a variable
Increment front

If front > rear (last element was dequeued), reset front and rear to -1
Return the stored value

6. getFront() Operation:
Check if queue is empty using isEmpty()

If empty, print "Queue is empty" and return error value (-1)

Otherwise, return the value at queue[front]

Problem with Simple Queue Implementation:

Space Inefficiency: Once the queue is full and elements are dequeued, the front moves forward
leaving unused space at the beginning
Cannot reuse the free space without resetting the queue completely
<a id="circular-queue"></a>

Circular Queue
A circular queue solves the problem of wasted space in a simple queue by making the array circular
(connecting the end to the beginning).
c
#include <stdio.h>
#define MAX 5 // Maximum size of circular queue

// Global variables
int cqueue[MAX]; // Array to store circular queue elements
int front = -1; // Index of front element
int rear = -1; // Index of rear element

// Function to check if circular queue is full

int isFull() {
if ((front == 0 && rear == MAX - 1) || (front == rear + 1)) {
return 1; // Return true (queue is full)
} else {
return 0; // Return false (queue is not full)
}
}

// Function to check if circular queue is empty

int isEmpty() {
if (front == -1) { // If front is -1
return 1; // Return true (queue is empty)
} else {
return 0; // Return false (queue is not empty)
}
}

// Function to add an element to the circular queue

void enqueue(int item) {
if (isFull()) { // Check if queue is full
printf("Circular Queue Overflow\n"); // Print error message
} else {
if (front == -1) { // If queue was empty
 front = 0; // Set front to the first position
}
rear = (rear + 1) % MAX; // Increment rear in circular manner
cqueue[rear] = item; // Place the item at rear position
printf("%d enqueued to circular queue\n", item);
}
}

// Function to remove an element from the circular queue

int dequeue() {
if (isEmpty()) { // Check if queue is empty
printf("Circular Queue Underflow\n"); // Print error message
return -1; // Return error value
} else {
int item = cqueue[front]; // Get the front item
if (front == rear) { // If the last item was dequeued
front = rear = -1; // Reset front and rear
} else {
front = (front + 1) % MAX; // Increment front in circular manner
}
return item; // Return the item
}
}

// Function to get the front element without removing it

int getFront() {
if (isEmpty()) { // Check if queue is empty
printf("Circular Queue is empty\n"); // Print error message
return -1; // Return error value
} else {
return cqueue[front]; // Return the front item
}
 }

// Sample usage
int main() {
enqueue(10); // Add 10 to queue
enqueue(20); // Add 20 to queue
enqueue(30); // Add 30 to queue
enqueue(40); // Add 40 to queue
printf("Front element: %d\n", getFront()); // Should print 10
printf("Dequeued: %d\n", dequeue()); // Should print 10
printf("Dequeued: %d\n", dequeue()); // Should print 20
// Now we can add more elements even though the array is "full"
enqueue(50); // Add 50 to queue
enqueue(60); // Add 60 to queue
printf("Front element after changes: %d\n", getFront()); // Should print 30
return 0;
}

Algorithm Explanation for Circular Queue Operations:

1. Initialization:
Create an array of fixed size (MAX)
Initialize front = -1 and rear = -1 (indicating empty queue)

2. isFull() Operation:
Check if (front == 0 AND rear == MAX-1) OR (front == rear+1)

If true, circular queue is full, return 1

Otherwise, return 0

3. isEmpty() Operation:
Check if front == -1
 If true, circular queue is empty, return 1

Otherwise, return 0

4. enqueue() Operation:
Check if queue is full using isFull()

If full, print "Circular Queue Overflow"

Otherwise:
If front == -1, set front = 0 (first element)

Update rear = (rear + 1) % MAX (circular increment)

Place the new item at cqueue[rear]

5. dequeue() Operation:
Check if queue is empty using isEmpty()
If empty, print "Circular Queue Underflow" and return error value (-1)

Otherwise:
Store the value at cqueue[front] in a variable

If front == rear (last element), reset front and rear to -1

Otherwise, update front = (front + 1) % MAX (circular increment)

Return the stored value

6. getFront() Operation:
Check if queue is empty using isEmpty()

If empty, print "Circular Queue is empty" and return error value (-1)
Otherwise, return the value at cqueue[front]

Visual Representation of Circular Queue:

 [0]
[4] [1]
↓
[3] [2]

<a id="priority-queue"></a>

Priority Queue
A priority queue is a queue where elements