DSA Learning Guide

A collection of elements stored at contiguous memory locations.

• Fast access with index O(1)
• Contiguous memory allocation
• Fixed size (in some languages)
• Insertion/deletion is O(n)

Linear data structure where elements are not stored at contiguous locations.

• Dynamic size
• Efficient insertions/deletions
• Random access is O(n)
• Extra memory for pointers

Linear data structure that follows LIFO (Last In, First Out) principle.

• Dynamic size (in linked list implementation)
• Efficient insertions/deletions (O(1))
• Random access is O(n)
• No extra memory required for pointers (in array implementation)

Linear data structure that follows FIFO (First In, First Out) principle.

• Dynamic size (in linked list implementation)
• Efficient insertions/deletions (O(1))
• Random access is O(n)
• Extra memory for pointers (in linked list implementation)

Double-ended queue where insertion and deletion can be performed from both ends.

• Dynamic size
• Efficient insertions/deletions (O(1) at both ends)
• Random access is O(n)
• Extra memory for pointers (in linked list implementation)

Complete binary tree used for priority-based operations.

• Dynamic size
• Efficient insertions/deletions (O(log n))
• Random access is O(n)
• Extra memory for pointers (in linked list-based implementation)

Hierarchical data structure with a root value and subtrees of children.

• Hierarchical representation
• Fast search, insert, delete (BST)
• Complex implementation
• Balancing required for performance

Algorithms that arrange elements in a certain order.

• Bubble Sort - O(n²)
• Merge Sort - O(n log n)
• Quick Sort - O(n log n)
• Heap Sort - O(n log n)

Algorithms for finding an item with specified properties in a collection.

• Linear Search - O(n)
• Binary Search - O(log n)
• Depth-First Search
• Breadth-First Search

Algorithms that operate on graphs to solve problems like shortest path.

• Dijkstra's Algorithm
• Bellman-Ford Algorithm
• Kruskal's Algorithm
• Prim's Algorithm

Mathematical notation that describes the limiting behavior of a function.

• Time complexity analysis
• Space complexity analysis
• Algorithm comparison
• Performance prediction

A method where the solution depends on solutions to smaller instances of the same problem.

• Elegant solutions
• Divide and conquer approach
• Stack overflow risk
• Memory intensive