1.
Arrays and Lists
Introduction & definitions
Memory allocation & indexing
Operations on 1D & 2D arrays/lists
Applications: sparse matrices & string manipulation
2. Linked Lists
Introduction and definition
Memory allocation
Types: singly, circular, doubly linked lists
Implementation operation
3. Stacks and Queues
Stack: definition, theory, and implementation using arrays and linked lists
Queue variations, including circular queue and priority queue
4. Trees and Heaps
Basic tree concepts: BT, BST
Advanced trees: AVL, (and optionally segment/Fenwick trees)
Heap structures: min-heap and max-heap
5. Sorting, Searching, Hashing, and Heaps
Searching: linear, binary, interpolation
Sorting: bubble, selection, insertion, merge, quick, heap sort
Heap methods
Hashing techniques: hash tables & collision handling
6. Algorithm Design Techniques
Brute-force methods
Divide-and-conquer
Greedy techniques
Dynamic programming
Backtracking (e.g., for combinatorial problems)
Sample Question Bank (LAB ASSESSMENT)
Here are some representative questions and mini-project prompts aligned with
SPPU’s lab assessment trends:
1. Linked Lists
o “Implement a circular doubly-linked list that supports insertion,
deletion, reversal, and display operations.”
2. Stacks & Queues
o “Convert infix expressions to postfix using a stack, then evaluate
the result.”
3. Trees
o “Build a BST for N values, delete a node with two children, and
traverse it in-order.”
4. Heaps
o “Implement a max-heap and use heap sort to sort an array of N
elements.”
5. Hashing
o “Create a hash table with open addressing (linear probing) and
measure average comparison counts for M searches.”
siddhantica.in+5github.com+5studocu.com+5iims.ac.in+2scribd.c
om+2unipune.ac.in+2iims.ac.in+1scribd.com+1github.com+4sppu
codes.vercel.app+4git.kska.io+4
6. Graphs
o “Given an undirected graph, write programs for BFS and DFS, and
count reachable vertices from a given source.”
7. Algorithms
o Greedy: “Implement Kruskal’s algorithm to find the MST for a
weighted undirected graph.”
o Backtracking: “Solve N-Queen problem for N = 8. Count all valid
configurations.”
o DP: “Implement 0/1 knapsack using dynamic programming to
compute maximum value for weight W.”
1. Arrays and Lists
1. INTRODUCTION
Arrays and Lists are fundamental linear data structures used to store collections of data.
Arrays use contiguous memory locations to store data, whereas Lists may use dynamic
memory and flexible sizing depending on the implementation.
2. ARRAYS
2.1 Definition
An array is a data structure consisting of a collection of elements (values or variables), each
identified by at least one array index or key. It stores elements of the same data type and
has a fixed size.
2.2 Declaration and Initialization (Example in C/C++)
int arr[5]; // Declaration
int arr[5] = {10, 20, 30, 40, 50}; // Initialization
2.3 Memory Representation
Arrays are stored in contiguous memory locations. If the base address is 1000 and the size
of int is 4 bytes, then arr[2] would be stored at address 1008 (1000 + 2*4).
2.4 Types of Arrays
One-dimensional Array
Two-dimensional Array (Matrix)
Multidimensional Arrays
2.5 Operations on Arrays
Operation Description Time Complexity
Access Retrieve an element at a specific index O(1)
Traverse Visit and print all elements O(n)
Insertion Insert element at specific index O(n)
Deletion Delete element from specific index O(n)
Searching Linear or binary search O(n) / O(log n)
2.6 Advantages
Fast element access
Simplicity in implementation
2.7 Disadvantages
Fixed size
Inefficient insertion and deletion
3. TWO-DIMENSIONAL ARRAYS
A 2D array is an array of arrays. It's used to store data in the form of a table or matrix.
Declaration in C/C++:
int matrix[3][4];
This declares a matrix with 3 rows and 4 columns.
Applications:
Matrix operations
Image processing
Game development
4. SPARSE MATRICES
A sparse matrix is a matrix that has a large number of zero elements.
Why Sparse Matrices?
Save space
Reduce computation time
Representations:
Triplet representation
Linked representation
5. STRINGS
Strings are arrays of characters ending with a null character (\0 in C).
Declaration:
char str[10] = "hello";
String Operations:
Copy
Concatenate
Compare
Length
Reverse
6. APPLICATIONS
Implementing other data structures (Stacks, Queues)
Mathematical computations
Data manipulation (text, records)
7. SUMMARY
Arrays are the most basic yet powerful data structures that form the building blocks of many
algorithms and higher-level structures. Mastery over arrays and their variations lays the
groundwork for tackling complex algorithmic challenges.
2. Linked Lists
INTRODUCTION
A linked list is a linear data structure where each element is a separate object, called a node.
Each node contains data and a reference (or link) to the next node in the sequence. Unlike
arrays, linked lists do not require contiguous memory and allow dynamic memory allocation.
2. TYPES OF LINKED LISTS
2.1 Singly Linked List
Each node points to the next node and the last node points to NULL.
struct Node {
int data;
struct Node* next;
};
2.2 Doubly Linked List
Each node contains two links: one to the next node and another to the previous node.
struct Node {
int data;
struct Node* prev;
struct Node* next;
};
2.3 Circular Linked List
The last node points to the first node instead of NULL.
2.4 Circular Doubly Linked List
A combination of circular and doubly linked list.
3. OPERATIONS ON LINKED LISTS
Operation Description Time Complexity
Traversal Visit all nodes O(n)
Insertion Insert at beginning, end, or middle O(1) to O(n)
Deletion Remove from beginning, end, or middle O(1) to O(n)
Search Find a node with given value O(n)
4. ADVANTAGES
Dynamic size
Efficient insertions/deletions
5. DISADVANTAGES
No direct access to elements
Uses more memory (due to pointers)
6. APPLICATIONS
Implementation of stacks and queues
Symbol tables in compilers
Dynamic memory allocation (e.g., malloc/free)
7. SUMMARY
Linked lists provide flexibility in memory usage and ease of insertion/deletion compared to
arrays. Understanding various types of linked lists is essential for building efficient data
structures.
3. Stacks and Queues
INTRODUCTION
Stacks and Queues are linear data structures that follow different principles for element
access. A stack uses the LIFO (Last In, First Out) principle, whereas a queue uses FIFO (First
In, First Out).
2. STACKS
2.1 Definition
A stack is a collection of elements with two primary operations:
Push: Adds an element to the top.
Pop: Removes the element from the top.
2.2 Implementation
Using Arrays
Using Linked Lists
#define MAX 100
int stack[MAX];
int top = -1;
2.3 Operations
Push(): Add an element
Pop(): Remove top element
Peek(): View top element
isEmpty(): Check if stack is empty
isFull(): Check if stack is full
2.4 Applications
Expression evaluation (Postfix, Prefix)
Backtracking (e.g., maze solving)
Function call stacks
3. QUEUES
3.1 Definition
A queue allows elements to be inserted at the rear and removed from the front.
3.2 Types of Queues
Simple Queue
Circular Queue
Priority Queue
Double Ended Queue (Deque)
3.3 Implementation
Using Arrays
Using Linked Lists
#define SIZE 5
int queue[SIZE];
int front = -1, rear = -1;
3.4 Operations
Enqueue(): Add element to rear
Dequeue(): Remove element from front
isFull() and isEmpty(): Check conditions
3.5 Applications
Job Scheduling
Buffer Handling
Resource Management
4. DIFFERENCE BETWEEN STACK AND QUEUE
Feature Stack (LIFO) Queue (FIFO)
Insertion At top At rear
Deletion From top From front
Use Case Backtracking Scheduling, Buffering
5. SUMMARY
Stacks and Queues are key linear structures useful in many real-world scenarios like task
scheduling, expression parsing, and memory management. Mastering their operations and
variations prepares students for advanced algorithmic problems.
4. Trees and Heaps
INTRODUCTION
A tree is a non-linear data structure consisting of nodes connected by edges. It is hierarchical
in nature and widely used in various applications such as databases, compilers, and network
routing.
A heap is a special tree-based data structure that satisfies the heap property.
2. TREES
2.1 Terminology
Root: Top node
Leaf: Node with no children
Parent/Child: Connected nodes
Subtree: Tree rooted at a child node
Height: Longest path from root to a leaf
2.2 Types of Trees
Binary Tree: Each node has at most 2 children
Binary Search Tree (BST): Left child < Root < Right child
AVL Tree: Self-balancing BST
B Tree / B+ Tree: Used in databases
2.3 Binary Tree Operations
Insertion
Deletion
Traversal:
o In-order (Left, Root, Right)
o Pre-order (Root, Left, Right)
o Post-order (Left, Right, Root)
o Level-order (Breadth-first)
2.4 Applications of Trees
Expression trees
File systems
Decision making (decision trees)
3. HEAPS
3.1 Definition
A heap is a complete binary tree satisfying the heap property:
Max Heap: Parent >= children
Min Heap: Parent <= children
3.2 Heap Operations
Insertion: Add node at bottom and percolate up
Deletion (Extract Max/Min): Remove root and heapify
Heapify: Convert an array to a heap
Heap Sort: Use heap to sort an array
3.3 Applications
Priority Queues
CPU Scheduling
Graph algorithms (Dijkstra's, Prim's)
4. SUMMARY
Trees and Heaps are powerful hierarchical data structures. Trees support efficient search and
hierarchical organization, while heaps are ideal for priority-based operations and sorting.
5. Sorting, Searching, Hashing,
and Heaps
INTRODUCTION
Sorting and Searching are fundamental operations in computer science used to manage and
retrieve data efficiently. Hashing is a technique to map data of arbitrary size to fixed-size
values (hash codes), allowing for constant time average-case lookup.
2. SORTING ALGORITHMS
Sorting arranges data in a particular order (ascending/descending).
2.1 Bubble Sort
Repeatedly swaps adjacent elements if they are in the wrong order.
Time Complexity: O(n²)
2.2 Selection Sort
Selects the smallest/largest element and swaps it with the first unsorted element.
Time Complexity: O(n²)
2.3 Insertion Sort
Builds the final sorted array one item at a time.
Time Complexity: O(n²)
2.4 Merge Sort
Divide and conquer strategy.
Time Complexity: O(n log n)
2.5 Quick Sort
Picks a pivot and partitions the array.
Time Complexity: Average O(n log n), Worst O(n²)
2.6 Heap Sort
Builds a heap and repeatedly extracts the max/min element.
Time Complexity: O(n log n)
2.7 Comparison Table
Algorithm Best Average Worst Space
Bubble Sort O(n) O(n²) O(n²) O(1)
Selection Sort O(n²) O(n²) O(n²) O(1)
Insertion Sort O(n) O(n²) O(n²) O(1)
Merge Sort O(n log n) O(n log n) O(n log n) O(n)
Quick Sort O(n log n) O(n log n) O(n²) O(log n)
Heap Sort O(n log n) O(n log n) O(n log n) O(1)
3. SEARCHING ALGORITHMS
3.1 Linear Search
Sequentially checks each element.
Time Complexity: O(n)
3.2 Binary Search
Works on sorted arrays. Repeatedly divides the array.
Time Complexity: O(log n)
Space Complexity: O(1)
3.3 Comparison Table
Method Time (Best) Time (Average) Time (Worst)
Linear Search O(1) O(n) O(n)
Binary Search O(1) O(log n) O(log n)
4. HASHING
Hashing is used to index and retrieve items in a database quickly.
4.1 Hash Functions
Maps keys to indices in a hash table
Example: index = key % table_size
4.2 Collision Resolution Techniques
Chaining: Use a linked list at each index
Open Addressing:
o Linear Probing
o Quadratic Probing
o Double Hashing
4.3 Load Factor
Load Factor (λ) = Number of elements / Table size
Helps in determining when to rehash
4.4 Applications of Hashing
Symbol tables
Caches
Password storage
Hash maps and hash sets
5. SUMMARY
Sorting helps organize data, searching retrieves data, and hashing allows fast access to data.
Efficient use of these techniques improves algorithm performance significantly.
