Data Structures Demystified: A Beginner’s Journey

Compare array and linked list by access cost and memory, noting arrays provide direct O(1) access while linked lists need O(n) traversal from the head with data and link overhead.

Create a linked list node with data and a next pointer, define a self-referential struct, and allocate memory dynamically using malloc with proper typecasting to struct node.

Create and link nodes in a singly linked list by dynamically allocating memory, initializing data, and setting next pointers. Update the head and links to form a multi-node list.

Learn insertion at the beginning in a singly linked list by setting the new node's next to the head, then updating the head. See related insertions at other positions.

Insert a node at the end of a singly linked list by traversing from the head. Use a temporary pointer to reach the last node and link the new node.

Learn how to insert a node at any position in a linked list, using a traversal pointer, counting the list length, and updating pointers to insert between nodes.

Explore the stack, a linear data structure with last-in, first-out behavior, its push, pop, and peek operations, and its use in string reversal, undo, and infix-postfix conversions.

Implement stacks with arrays and linked lists, including static and dynamic memory. Master push, pop, peek, display, overflow, underflow, and time complexities.

Explore tree terminologies, including root, edges, parent and child, degree, leaves, siblings, height, depth, subtree and path, plus array or linked list representations in binary and complete binary trees.

Explore AVL trees, a self-balancing binary search tree, balancing height with rotations to keep operations like search, insert, and delete at O(log n).

Learn how hashing maps data into a hash table via a hash function, enabling insertion, deletion, and search. Explore static vs dynamic hashing and methods like mid square.

Explore how collisions arise when multiple keys share a hash value and learn separate chaining, an open hashing approach using a linked list in the hash table to resolve them.

Demystify open addressing collision resolution with linear probing. Apply hash(key) mod m and probe i steps (0-9) to place keys like 89, 18, 49, and 58.

Explore collision resolution with quadratic probing. See how keys 89, 18, 49, 58, and 69 are placed using hash(key) mod table size and i squared to resolve collisions.

Explain how double hashing resolves collisions in addressing using two hash functions u and v, via the probe sequence (u + i v) mod m, with r as a prime.

Explore topological sorting to obtain a linear ordering of DAG vertices where predecessors precede successors, and learn how indegrees guide multiple orderings for applications like job scheduling and instruction scheduling.

Explore breadth first search, a queue-based graph traversal that yields a spanning tree by visiting non-visited adjacent vertices from a starting node and enqueuing them until the queue empties.

Explore depth first search as a graph traversal method, using a stack to visit non-visited adjacent vertices, backtrack by popping, and obtain a spanning tree with no cycles.

Explore graphs as non-linear data structures with vertices and edges, differentiate undirected and directed graphs, and learn representations via adjacency matrix and adjacency list, including in-degree and out-degree.

Learn Prim's algorithm for constructing a minimum spanning tree by starting at a vertex, expanding through smallest edges, avoiding cycles, and computing the minimum spanning tree cost.

Explore Kruskal's algorithm for finding a minimum spanning tree by sorting edges by weight, selecting non-cycle edges, and building a spanning tree in a greedy, edge-by-edge process.

Explore Dijkstra's shortest path algorithm for finding the minimum distance between vertices on graphs with non-negative edges, using a source-based update of tentative distances in directed and undirected graphs.