### Key Terms in Data Structures

1. Data Structure: A data structure is a way of organizing and storing data so that it can be accessed and modified efficiently.

2. Abstract Data Type (ADT): An abstract data type is a model for data structures that specifies the type of data stored, the operations supported, and the types of parameters of the operations.

3. Algorithm: A step-by-step procedure for performing a task in a finite amount of time.

4. Array: A collection of elements identified by index or key, stored in contiguous memory locations.

5. Linked List: A linear collection of data elements, called nodes, where each node points to the next node by means of a pointer.

6. Stack: A collection of elements that supports last-in, first-out (LIFO) semantics for insertion and deletion.

7. Queue: A collection of elements that supports first-in, first-out (FIFO) semantics for insertion and deletion.

8. Tree: A hierarchical data structure consisting of nodes, with a single node as the root, and sub-nodes as children.

9. Binary Tree: A tree data structure in which each node has at most two children, referred to as the left child and the right child.

10. Binary Search Tree (BST): A binary tree where the left child of a node contains only nodes with values less than the parent node, and the right child only nodes with values greater than the parent node.

11. Heap: A specialized tree-based data structure that satisfies the heap property. In a max heap, for any given node, the value of the node is greater than or equal to the values of its children.

12. Graph: A collection of nodes, called vertices, and the connections between them, called edges.

13. Hash Table: A data structure that maps keys to values for efficient lookup.

### Classification of Data Structures

1. Linear Data Structures: Elements are arranged in a sequential manner. Examples include arrays, linked lists, stacks, and queues.

2. Non-linear Data Structures: Elements are arranged in a hierarchical manner. Examples include trees and graphs.

### Applications of Data Structures

1. Arrays:

- Used in database implementations to store records.

- Used in dynamic programming for tabulation.

2. Linked Lists:

- Used in implementing other data structures like stacks, queues, and graphs.

- Used in dynamic memory allocation.

3. Stacks:

- Used in expression evaluation and syntax parsing.

- Used in backtracking algorithms.

4. Queues:

- Used in scheduling algorithms (e.g., CPU scheduling).

- Used in breadth-first search (BFS) algorithms.

5. Trees:

- Used in hierarchical data representation, like file systems.

- Used in databases and indexing.

6. Graphs:

- Used in social networks to represent relationships.

- Used in network routing algorithms.

7. Hash Tables:

- Used in database indexing.

- Used in caching mechanisms.

### Properties of Data Structures

1. Time Complexity: The amount of time an algorithm takes to complete as a function of the length of the input.

2. Space Complexity: The amount of memory an algorithm takes to complete as a function of the length of the input.

3. Dynamic vs. Static: Dynamic data structures can grow and shrink at runtime, while static ones have fixed size.

4. Homogeneous vs. Heterogeneous: Homogeneous data structures store elements of the same type, whereas heterogeneous ones can store elements of different types.

### Comparison of Different Data Structures

1. Array vs. Linked List:

- Array:

- Fixed size.

- Efficient random access (O(1)).

- Inefficient insertions and deletions (O(n)).

- Linked List:

- Dynamic size.

- Efficient insertions and deletions (O(1)).

- Inefficient random access (O(n)).

2. Stack vs. Queue:

- Stack:

- LIFO structure.

- Operations: push, pop.

- Queue:

- FIFO structure.

- Operations: enqueue, dequeue.

3. Binary Search Tree (BST) vs. Heap:

- BST:

- Ordered structure.

- Efficient search, insertion, deletion (O(log n) on average).

- Balanced BSTs (e.g., AVL, Red-Black Trees) ensure O(log n) operations.

- Heap:

- Complete binary tree.

- Efficient access to the largest (max-heap) or smallest (min-heap) element (O(1)).

- Insertion and deletion are O(log n).

4. Hash Table vs. Binary Search Tree:

- Hash Table:

- Average time complexity for search, insert, delete is O(1).

- Efficient for quick lookups.

- Hash collisions need to be handled.

- Binary Search Tree:

- Ordered structure.

- O(log n) operations in balanced trees.

- Provides ordered traversal of elements.

Each data structure has its strengths and weaknesses, and the choice depends on the specific requirements of the application, such as the type of operations performed most frequently and the size and nature of the data.

### Important Points and Terms for Data Structures in C Course Flashcards

#### Key Concepts

1. Data Structure:

- Definition: A way of organizing and storing data for efficient access and modification.

- Types: Linear and Non-linear.

2. Abstract Data Type (ADT):

- Definition: A model for data structures that specifies the type of data stored, the operations supported, and the types of parameters of the operations.

#### Linear Data Structures

1. Array:

- Fixed-size sequential collection of elements.

- Access via index.

- Time Complexity: Access \(O(1)\), Insertion/Deletion \(O(n)\).

2. Linked List:

- A collection of nodes where each node contains data and a reference to the next node.

- Types: Singly Linked List, Doubly Linked List.

- Time Complexity: Access \(O(n)\), Insertion/Deletion \(O(1)\).

3. Stack:

- LIFO (Last In First Out) structure.

- Operations: Push, Pop, Peek.

- Time Complexity: \(O(1)\) for push and pop.

4. Queue:

- FIFO (First In First Out) structure.

- Operations: Enqueue, Dequeue, Front, Rear.

- Time Complexity: \(O(1)\) for enqueue and dequeue.

#### Non-linear Data Structures

1. Tree:

- Hierarchical structure with a root node and child nodes.

- Types: Binary Tree, Binary Search Tree (BST), AVL Tree, Red-Black Tree.

2. Binary Search Tree (BST):

- Each node has at most two children.

- Left child < Parent node < Right child.

- Time Complexity: Average \(O(\log n)\), Worst \(O(n)\).

3. Heap:

- Complete binary tree.

- Types: Min-Heap, Max-Heap.

- Time Complexity: Insertion/Deletion \(O(\log n)\).

4. Graph:

- A set of vertices connected by edges.

- Types: Directed, Undirected, Weighted, Unweighted.

- Representations: Adjacency Matrix, Adjacency List.

#### Common Operations and Algorithms

1. Traversal:

- Tree Traversal: In-order, Pre-order, Post-order.

- Graph Traversal: Depth-First Search (DFS), Breadth-First Search (BFS).

2. Sorting:

- Bubble Sort: \(O(n^2)\).

- Selection Sort: \(O(n^2)\).

- Insertion Sort: \(O(n^2)\).

- Merge Sort: \(O(n \log n)\).

- Quick Sort: Average \(O(n \log n)\), Worst \(O(n^2)\).

- Heap Sort: \(O(n \log n)\).

- Radix Sort: \(O(nk)\).

3. Searching:

- Linear Search: \(O(n)\).

- Binary Search: \(O(\log n)\) (requires sorted array).

4. Hashing:

- Hash Table: Key-value pairs for efficient look-up.

- Collision Handling: Chaining, Open Addressing.

#### Complexity Analysis

1. Time Complexity:

- Best Case: The scenario where the algorithm performs the minimum number of steps.

- Average Case: The scenario that represents the expected number of steps.

- Worst Case: The scenario where the algorithm performs the maximum number of steps.

2. Space Complexity:

- The amount of memory an algorithm uses as a function of the length of the input.

#### Memory Management

1. Dynamic Memory Allocation:

- Functions: malloc(), calloc(), realloc(), free().

- Use of pointers for dynamic allocation.

#### Miscellaneous Concepts

1. Recursion:

- A function calling itself to solve smaller instances of the same problem.

- Base Case and Recursive Case.

2. Pointers:

- Variables that store the address of another variable.

- Usage: Dynamic memory allocation, Linked Lists.

#### Key Terms

1. Node: Basic unit of a data structure, like linked lists and trees, containing data and pointers/references.

2. Edge: Connection between two nodes in a graph.

3. Root: Top node in a tree.

4. Leaf: A node with no children in a tree.

5. Parent/Child: Relationship between nodes in a tree.

6. Degree: Number of children a node has.

7. Height: Length of the longest path from the root to a leaf.

8. Depth: Length of the path from the root to a node.

These key concepts, operations, algorithms, and terms provide a comprehensive overview for creating flashcards for a Data Structures in C course