UNIT-1

1. Abstract Data Types (ADT)

An Abstract Data Type (ADT) is a mathematical model for data types where only the behavior is
defined but not the implementation. It's a way of looking at a data structure that focuses on what it
does rather than how it does it.

Key Characteristics of ADTs:

1. Encapsulation: ADTs bundle data and the operations that can be performed on that data.

2. Abstraction: They provide a clear separation between the abstract properties and the concrete
implementation.

3. Information Hiding: The internal workings are hidden from the user of the ADT.

4. Well-defined Interface: ADTs specify a set of operations that can be performed on the data.

Components of an ADT:

1. Data: The values stored in the ADT.

2. Operations: The functions that can manipulate the data.

3. Axioms: Rules that describe the behavior of the operations.

Example of an ADT: Stack

Let's define a Stack ADT:

1. Data:

• A collection of elements

2. Operations:

• create(): Create an empty stack

• push(element): Add an element to the top of the stack
• pop(): Remove and return the top element from the stack
• peek(): Return the top element without removing it
• isEmpty(): Check if the stack is empty
• size(): Return the number of elements in the stack

3. Axioms:

• pop(push(S, x)) = S (popping after pushing returns the original stack)

• peek(push(S, x)) = x (peeking after pushing returns the pushed element)
• isEmpty(create()) = true (a newly created stack is empty)
Advantages of ADTs:

1. Modularity: ADTs allow for better organization of code into logical units.

2. Flexibility: The implementation can be changed without affecting the programs that use the ADT.

3. Reusability: Once defined, an ADT can be reused in many different programs.

4. Complexity Management: ADTs hide the complex implementation details from the user.

5. Ease of Debugging: Since the interface is well-defined, it's easier to locate and fix bugs.

Disadvantages of ADTs:

1. Performance Overhead: The abstraction layer can sometimes lead to decreased performance.

2. Learning Curve: Understanding and implementing ADTs can be challenging for beginners.

3. Potential Overengineering: For very simple problems, using ADTs might be unnecessary
complexity.

Implementation of ADTs:

ADTs can be implemented in various ways. For example, a Stack ADT could be implemented using:

1. Arrays

2. Linked Lists

3. Dynamic Arrays

Applications of ADTs:

1. Compiler Design: Symbol tables are often implemented as ADTs.

2. Database Management Systems: The implementation of indices and data storage can use ADTs.

3. Operating Systems: Process scheduling and memory management often use ADT concepts.

4. Graphics: Many graphics libraries use ADTs to represent complex shapes and transformations.
This diagram illustrates the key components of an Abstract Data Type: Data, Operations, and Axioms.
It also shows examples of common ADTs like Stack, Queue, List, and Tree.

In conclusion, Abstract Data Types are a fundamental concept in computer science that allows
programmers to think about data structures in terms of their behavior rather than their
implementation. This abstraction provides numerous benefits in terms of code organization,
reusability, and maintainability. Understanding ADTs is crucial for designing efficient and scalable
software systems.

2. Stack

A Stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle. This means that
the last element added to the stack will be the first one to be removed.

Key Characteristics:

1. LIFO (Last-In-First-Out) ordering

2. Elements are added and removed from the same end (top)

3. Access is restricted to the top element

Basic Operations:

1. push(element): Adds an element to the top of the stack

2. pop(): Removes and returns the top element from the stack

3. peek() or top(): Returns the top element without removing it

4. isEmpty(): Checks if the stack is empty

5. size(): Returns the number of elements in the stack

Time Complexity:

- All basic operations (push, pop, peek, isEmpty, size) have O(1) time complexity
This diagram shows the key aspects of a Stack, including its LIFO (Last-In-First-Out) principle, main
operations, common applications, and implementation methods.

Advantages of Stack:

1. Simple and easy to implement

2. Efficient for LIFO operations

3. Memory is managed efficiently (elements are added/removed from one end only)

4. Useful for backtracking algorithms

5. Helps in implementing function calls (call stack)

Disadvantages of Stack:

1. Limited access (only to the top element)

2. Not suitable for applications requiring random access to elements

3. Fixed size in array-based implementation (can be mitigated with dynamic arrays)

4. Potential for stack overflow if not managed properly

Applications of Stack:

1. Function Call Management:

• The call stack keeps track of function calls, local variables, and return addresses.

2. Expression Evaluation:

• Used in calculators for evaluating arithmetic expressions (infix to postfix conversion and
evaluation).

3. Undo Mechanism:

• Stacks can store the history of operations, allowing for easy undo functionality in
applications.

4. Backtracking Algorithms:

• Used in solving puzzles like mazes, where you need to keep track of the path and backtrack if
needed.

5. Parentheses Matching:

• Checking for balanced parentheses in expressions.

6. Browser History:

• The back button in web browsers uses a stack to keep track of previously visited pages.
7. Memory Management:

• Used in memory management for storing local variables and parameters in programming
languages.

In conclusion, the Stack data structure is a fundamental concept in computer science with numerous
practical applications. Its LIFO principle makes it ideal for scenarios where the most recently added
item needs to be processed first. Understanding stacks is crucial for many algorithms and system
designs, particularly in areas like compiler design, expression evaluation, and memory management.

3. Queue

A Queue is a linear data structure that follows the First-In-First-Out (FIFO) principle. This means that
the first element added to the queue will be the first one to be removed.

Key Characteristics:

1. FIFO (First-In-First-Out) ordering

2. Elements are added at one end (rear) and removed from the other end (front)

3. Follows the principle of "first come, first served"

Basic Operations:

1. enqueue(element): Adds an element to the rear of the queue

2. dequeue(): Removes and returns the front element from the queue

3. front(): Returns the front element without removing it

4. rear(): Returns the rear element without removing it

5. isEmpty(): Checks if the queue is empty

6. size(): Returns the number of elements in the queue

Time Complexity:

- All basic operations (enqueue, dequeue, front, rear, isEmpty, size) have O(1) time complexity
This diagram illustrates the main concepts of a Queue, including its FIFO (First-In-First-Out) principle,
primary operations, common applications, and implementation methods.

Advantages of Queue:

1. Simple and intuitive to understand and implement

2. Efficient for FIFO operations

3. Useful for managing tasks that need to be processed in order

4. Helps in implementing level-order traversals in trees

Disadvantages of Queue:

1. Limited access (only to front and rear elements)

2. Not suitable for applications requiring random access to elements

3. Can be inefficient for large queues if implemented using arrays (due to dequeue operation)

4. Potential for queue overflow in fixed-size implementations

Applications of Queue:

1. Task Scheduling:

• Operating systems use queues for process scheduling and managing task priorities.

2. Breadth-First Search (BFS):

• Queues are essential in implementing BFS algorithms for graph traversal.

3. Print Job Spooling:

• Printer queues manage the order of print jobs.

4. Buffering:

• Used in scenarios where data is transferred asynchronously between processes (e.g., IO

buffers).

5. Handling of Requests:

• Web servers use queues to manage incoming client requests.

6. Breadth-First Tree Traversal:

• Queues are used to visit all the nodes of a tree level by level.

7. Simulating Real-World Queues:

 • Modeling waiting lines in various scenarios (e.g., customer service systems).

In conclusion, the Queue data structure is fundamental in computer science and has numerous
practical applications. Its FIFO principle makes it ideal for scenarios where tasks or data need to be
processed in the order they arrive. Understanding queues is crucial for many algorithms and system
designs, particularly in areas like process scheduling, breadth-first search, and managing
asynchronous operations.

4. Circular Queue

A Circular Queue is a linear data structure that follows the First-In-First-Out (FIFO) principle and is an
improvement over the standard queue. It's also known as a "Ring Buffer."

Key Characteristics:

- Uses a fixed-size array and treats it as circular

- Efficiently utilizes memory by reusing empty spaces

- Uses two pointers: front (for deletion) and rear (for insertion)

- Employs modulo arithmetic to wrap around the queue

Operations:

1. Enqueue: Add an element to the rear of the queue

2. Dequeue: Remove an element from the front of the queue

3. Front: Get the front element without removing it

4. Rear: Get the rear element without removing it

5. isEmpty: Check if the queue is empty

6. isFull: Check if the queue is full

Advantages:

- Better memory utilization compared to a linear queue

- Prevents queue overflow when there's space available

- All operations have O(1) time complexity

Disadvantages:

- Fixed size (cannot grow dynamically)

- Slightly more complex implementation than a linear queue

- Can be confusing for beginners due to its circular nature

Applications:

1. CPU scheduling in operating systems

2. Memory management

3. Traffic Management Systems

4. Data streaming, especially in situations where data can be overwritten (e.g., sensor data
collection)

This diagram shows the key features of a Circular Queue, including its structure with front and rear
pointers, main operations, advantages, and common applications.

5. Double Ended Queue (Deque)

A Double Ended Queue, or Deque, is a linear data structure that allows insertion and deletion of
elements from both ends.

Key Characteristics:

- Elements can be added or removed from either the front or the rear

- Combines features of both stacks and queues

- Can be implemented using a doubly linked list or a dynamic array

Operations:

1. insertFront: Add an element to the front

2. insertRear: Add an element to the rear

3. deleteFront: Remove an element from the front

4. deleteRear: Remove an element from the rear

5. getFront: Get the front element without removing it

6. getRear: Get the rear element without removing it

7. isEmpty: Check if the deque is empty

8. isFull: Check if the deque is full (for array implementations)

Types of Deques:

1. Input Restricted Deque: Input is restricted to one end, but output is possible from both ends

2. Output Restricted Deque: Output is restricted to one end, but input is possible at both ends

Advantages:

- Versatile: Can be used as both stack and queue

- Efficient for adding/removing elements at both ends

- Useful in scenarios requiring bi-directional traversal

Disadvantages:

- More complex implementation than simple stacks or queues

- Slightly higher memory overhead in some implementations

Applications:

1. Implementing undo functionality in software

2. Managing browser history (forward and backward navigation)

3. Palindrome checking

4. Implementing A-Steal job scheduling algorithm

6. Applications of Stack

Stacks have numerous applications in computer science and programming. Here are some key
applications:

1. Function Call Management (Call Stack):

• Manages function calls and local variables

• Keeps track of the return address for each function call

2. Expression Evaluation:

• Used in calculators for evaluating arithmetic expressions

• Converts infix expressions to postfix (or prefix) notation
• Evaluates postfix expressions

3. Parentheses Matching:

• Checks for balanced parentheses in expressions

• Used in syntax checking for programming languages

4. Backtracking Algorithms:

• Helps in solving maze problems

• Used in games like chess for move analysis

5. Undo Mechanism:

• Implements undo functionality in text editors and other applications

6. Browser History:

• Manages forward and backward navigation in web browsers

7. Evaluating Arithmetic Expressions using Stack

Stacks play a crucial role in evaluating arithmetic expressions. The process typically involves two main
steps:

1. Infix to Postfix Conversion:

• Converts an infix expression (e.g., "3 + 4 * 2") to postfix notation (e.g., "3 4 2 * +")
• Uses a stack to manage operators and their precedence
• Operands are directly added to the output

2. Postfix Evaluation:

• Evaluates the postfix expression using a stack

• Scans the expression from left to right
• Pushes operands onto the stack
• When an operator is encountered, pops the required number of operands, applies the
operator, and pushes the result back

Steps in the Process:

1. Tokenize the infix expression

2. Convert infix to postfix using a stack

3. Evaluate the postfix expression using another stack

Advantages:

- Eliminates the need for parentheses and operator precedence rules

- Allows for single-pass evaluation of expressions

- Simplifies the evaluation process

This completes the overview of all the remaining topics, including both detailed information and
Mermaid diagrams for each. These concepts are fundamental in understanding data structures and
their applications in computer science and programming.
8. Applications of Queue

Queues are widely used in various scenarios in computer science and real-world applications:

1. Task Scheduling in Operating Systems:

• Manages processes waiting to be executed

• Implements fair scheduling algorithms

2. Breadth-First Search (BFS):

• Used in graph algorithms for traversal

• Helps find the shortest path in unweighted graphs

3. Buffering:

• Manages data streams in input/output operations

• Used in video streaming and data transfer between processes

4. Print Job Spooling:

• Manages the order of print jobs sent to a printer

5. Handling of Requests:

• Manages incoming requests in web servers

• Implements load balancing in distributed systems

6. Breadth-First Tree Traversal:

• Visits all nodes of a tree level by level

7. Implementing Cache:

• Manages recently accessed items in a cache system

9. Linked Lists

Linked Lists are fundamental data structures in computer science. They consist of a sequence of
elements called nodes, where each node contains data and a reference (or link) to the next node in
the sequence.

Key characteristics of linked lists:

- Dynamic size: They can grow or shrink during program execution.

- Non-contiguous memory: Nodes can be scattered in memory.

- Efficient insertion and deletion: Especially at the beginning of the list (O(1) time).

- Sequential access: No direct access to elements by index.

The basic structure of a linked list node typically includes:

- Data: The actual value or information stored in the node.

- Next pointer: A reference to the next node in the sequence.

The LinkedList class usually maintains a reference to the head node (the first node in the list) and
provides methods for common operations like insertion, deletion, and traversal.

10. Singly Linked List

A Singly Linked List is the most basic form of a linked list. In this structure, each node points only to
the next node in the sequence, and the last node points to NULL, indicating the end of the list.

Key features:

- Unidirectional traversal: You can only move forward through the list.

- Head pointer: A reference to the first node in the list is maintained.

- Tail pointer (optional): Some implementations keep a reference to the last node for quick append
operations.

Operations on a Singly Linked List:

1. Insertion: Can be done at the beginning (O(1)), end (O(n) or O(1) with tail pointer), or middle
(O(n)).

2. Deletion: Can be done from the beginning (O(1)), end (O(n)), or middle (O(n)).

3. Traversal: Requires iterating through the list from the beginning (O(n)).

4. Search: Requires linear search, traversing the list until the element is found (O(n)).

Advantages:

- Simple implementation

- Memory efficient (compared to doubly linked lists)

- Efficient insertion and deletion at the beginning

Disadvantages:

- No backward traversal

- Accessing elements by index is inefficient

11. Circularly Linked List

A Circularly Linked List is a variation where the last node points back to the first node, creating a
circular structure. This can be implemented with either singly or doubly linked lists.

Key features:

- No NULL termination: The last node points to the first node instead of NULL.

- No clear end: You can traverse the entire list starting from any node.

- Circular nature: Useful for applications that require cyclic data representation.

Operations on a Circularly Linked List:

1. Insertion: Similar to regular linked lists, but special care is needed for the last node.

2. Deletion: Requires updating the links to maintain the circular structure.

3. Traversal: Can start from any node and continue until reaching the starting point again.

Advantages:

- Useful for implementing circular buffers or queues

- Efficient for applications that need to cycle through all elements repeatedly

- No need to check for NULL when traversing

Disadvantages:

- Slightly more complex implementation than singly linked lists

- Risk of infinite loops if not handled carefully

12. Doubly Linked List

A Doubly Linked List enhances the basic linked list structure by adding a previous pointer to each
node. This allows for bidirectional traversal of the list.

Key features:

- Bidirectional traversal: You can move both forward and backward through the list.

- Two pointers per node: Each node has 'next' and 'prev' pointers.

- Head and Tail pointers: Often maintained for quick access to both ends of the list.

Operations on a Doubly Linked List:

1. Insertion: Can be done at the beginning, end, or middle (all O(1) if pointers are available).

2. Deletion: Can be done from any position (O(1) if node reference is available).

3. Traversal: Can be done in both directions.

4. Search: Can be optimized by starting from the closer end.

Advantages:

- Bidirectional traversal

- Efficient insertion and deletion at both ends

- Easier implementation of certain algorithms (e.g., LRU cache)

Disadvantages:

- More memory usage due to extra pointer

- Slightly more complex implementation

13. Applications of Linked Lists

Linked Lists find applications in various areas of computer science and software development due to
their flexibility and efficient insertion/deletion operations.

Key applications include:

1. Implementation of other data structures:

• Stacks and Queues: Linked lists provide an efficient basis for these structures.
• Hash Tables: Used for handling collisions in chaining-based hash tables.
• Graphs: Adjacency lists in graph representations often use linked lists.

2. Memory Management:

• Memory Allocation: Operating systems use linked lists to keep track of free memory blocks.
• Garbage Collection: Some garbage collection algorithms use linked lists to track object
references.

3. Software Features:

• Music Player Applications: Playlist management with easy addition, removal, or reordering of
songs.
• Browser Functionality: Back/Forward navigation history using doubly linked lists.
• Text Editors: Maintaining a history of actions for undo/redo operations.
• Image Viewer Applications: Navigating through a series of images using prev/next
operations.

4. Mathematical Operations:

• Polynomial Arithmetic: Representing polynomials where each term is a node in the list,
allowing efficient addition and multiplication.

5. Programming Language Implementation:

• Symbol Tables: Managing identifiers and their attributes during compilation.

• Function Call Stack: Implementing the call stack for function invocations.
 UNIT-2

1. Binary Tree

A binary tree is a hierarchical data structure in which each node has at most two children, referred to
as the left child and the right child.

Key characteristics:

- Each node contains:

- Data

- Reference to the left child

- Reference to the right child

- The topmost node is called the root

- Nodes with no children are called leaves

- The depth of a node is the number of edges from the root to that node

- The height of a tree is the depth of the deepest leaf node

Types of Binary Trees:

1. Full Binary Tree: Every node has 0 or 2 children

2. Complete Binary Tree: All levels are filled except possibly the last, which is filled from left to right

3. Perfect Binary Tree: All internal nodes have two children and all leaves are at the same level

4. Balanced Binary Tree: Height of the left and right subtrees of every node differs by at most one

5. Degenerate (or pathological) Tree: Every parent node has only one child
Applications of Binary Trees:

1. File systems for efficient searching

2. Expression evaluation and syntax parsing

3. Huffman coding trees for data compression

4. Binary Search Trees for fast lookup, insertion, and deletion

5. Priority Queues

Time Complexity:

- Insertion: O(h), where h is the height of the tree

- Searching: O(h)

- Deletion: O(h)

Space Complexity: O(n), where n is the number of nodes

2. Expression Trees

Expression trees are binary trees used to represent arithmetic or boolean expressions. They provide
an efficient way to evaluate and manipulate mathematical expressions.

Properties of Expression Trees:

- Leaf nodes represent operands (numbers or variables)

- Internal nodes represent operators (+, -, *, /, etc.)

- The structure of the tree represents the order of operations

Building an Expression Tree:

1. Tokenize the expression

2. Convert to postfix notation using the Shunting Yard algorithm

3. Build the tree from the postfix notation

Applications of Expression Trees:

1. Compiler design for parsing and evaluating expressions

2. Symbolic computation in computer algebra systems

3. Query optimization in databases

3. Binary Tree Traversals

Traversal is the process of visiting all nodes in a tree. There are three main types of binary tree
traversals:

a) In-order Traversal: Left subtree, Root, Right subtree

b) Pre-order Traversal: Root, Left subtree, Right subtree

c) Post-order Traversal: Left subtree, Right subtree, Root

For this tree:

- In-order: 4, 2, 5, 1, 6, 3, 7

- Pre-order: 1, 2, 4, 5, 3, 6, 7

- Post-order: 4, 5, 2, 6, 7, 3, 1

Applications of Tree Traversals:

1. Expression evaluation (postfix, prefix notations)

2. Creating a copy of a tree

3. Checking if two trees are identical

4. Finding the height of a tree

5. Serialization and deserialization of binary trees

Time Complexity: O(n), where n is the number of nodes

Space Complexity: O(h) for recursive implementation, where h is the height of the tree
4. Applications of Trees

Trees have numerous applications in computer science and real-world scenarios:

1. File Systems:

• Directories and files are organized in a tree structure

• Allows for efficient organization and retrieval of data

2. Organization Charts:

• Representing hierarchical structures in companies

• Visualizing reporting relationships and company structure

3. DOM (Document Object Model):

• Representing structure of XML and HTML documents

• Allows for efficient parsing and manipulation of web documents

4. Decision Trees:

• Used in machine learning for classification and regression

• Provides a visual representation of decision-making processes

5. Syntax Trees:

• Used in compilers to parse and represent programming language syntax

• Facilitates code analysis and optimization

6. Network Routing:

• Representing network topologies

• Finding optimal paths for data transmission

7. Game Trees:

• Representing possible moves in games like chess or tic-tac-toe

• Used in AI for game strategy and decision making

8. Genealogy and Family Trees:

• Representing family relationships and ancestry

9. Database Indexing:

• B-trees and B+ trees are used for efficient data retrieval in databases

10. Huffman Coding:

• Used for data compression

• Builds a tree based on character frequencies for optimal encoding
5. Huffman Algorithm

Huffman coding is a data compression technique that uses variable-length codes to represent
characters based on their frequency of occurrence. It's an optimal prefix-free coding commonly used
for lossless data compression.

Steps of the Huffman Algorithm:

1. Calculate the frequency of each character in the input

2. Create a leaf node for each character and add it to a priority queue

3. While there is more than one node in the queue:

• Remove the two nodes with the lowest frequency

• Create a new internal node with these two nodes as children
• Set the frequency of the new node as the sum of the two child nodes
• Add the new node back to the queue

4. The remaining node is the root of the Huffman tree

This Huffman tree represents character frequencies: A(3), B(5), C(6), D(6)

Applications of Huffman Coding:

1. Data compression in file formats (e.g., JPEG, MP3)

2. Error correction in data transmission

3. Prefix codes in cryptography

4. Lossless data compression algorithms

Time Complexity:

- Building the Huffman tree: O(n log n), where n is the number of unique characters

- Encoding: O(n), where n is the length of the input text

- Decoding: O(n), where n is the length of the encoded text

Space Complexity: O(k), where k is the number of unique characters in the input

6. Binary Search Tree (BST)

A Binary Search Tree is a binary tree with the following properties:

- The left subtree of a node contains only nodes with keys less than the node's key

- The right subtree of a node contains only nodes with keys greater than the node's key

- Both the left and right subtrees must also be binary search trees

- No two nodes can have the same value

Operations and their time complexities:

- Insertion: O(h) average case, O(n) worst case

- Deletion: O(h) average case, O(n) worst case

- Search: O(h) average case, O(n) worst case

Where h is the height of the tree, and n is the number of nodes.

In a balanced BST, h = log(n), giving O(log n) time complexity for these operations.

Applications of Binary Search Trees:

1. Implementing dynamic sets and dictionaries

2. Used in many search applications where data is constantly entering and leaving

3. Used in implementing indexing in databases

4. Useful in implementing suffix trees (used in string processing algorithms)

7. Balanced Trees

Balanced trees are binary search trees designed to maintain balance to ensure O(log n) time
complexity for operations. The balance condition varies depending on the type of balanced tree.

Types of Balanced Trees:

1. AVL Trees

2. Red-Black Trees

3. B-Trees

4. Splay Trees

8. AVL Tree

AVL trees, named after inventors Adelson-Velsky and Landis, are self-balancing binary search trees. In
an AVL tree, the heights of the two child subtrees of any node differ by at most one.

Balance Factor = Height of Left Subtree - Height of Right Subtree

For any node in an AVL tree, the balance factor must be -1, 0, or 1.
Balancing is maintained through rotations:

1. Left Rotation

2. Right Rotation

3. Left-Right Rotation

4. Right-Left Rotation

Time Complexity:

- Insertion: O(log n)

- Deletion: O(log n)

- Search: O(log n)

Space Complexity: O(n) for storing n nodes

Applications of AVL Trees:

1. Database indexing

2. Implementing sets and maps in programming languages

3. In-memory sorting of large datasets

4. Used in file systems to maintain directory structures

9. B-Tree

B-Trees are self-balancing search trees designed to work efficiently on disk storage. They are
commonly used in databases and file systems.
Properties of a B-tree of order m:

1. Every node has at most m children

2. Every non-leaf node (except root) has at least ⌈m/2⌉ children

3. The root has at least two children if it is not a leaf node

4. A non-leaf node with k children contains k-1 keys

5. All leaves appear in the same level

Time Complexity:

- Search: O(log n)

- Insertion: O(log n)

- Deletion: O(log n)

Space Complexity: O(n)

Applications of B-Trees:

1. Database indexing

2. File systems (e.g., NTFS, HFS+, ext4)

3. Storing blocks in large storage systems

10. Splay Trees

Splay trees are self-adjusting binary search trees that move recently accessed elements closer to the
root. This makes them efficient for implementing caches or data structures with temporal locality.
Key Operations:

- Splay: Moves a node to the root using rotations

- Insert: Insert normally, then splay the inserted node

- Delete: Splay the node to be deleted, then remove it

Time Complexity:

- Search: O(log n) amortized

- Insert: O(log n) amortized

- Delete: O(log n) amortized

Space Complexity: O(n)

Applications of Splay Trees:

1. Implementing caches

2. Memory management in operating systems

3. Implementing undo functionality in text editors

4. Network routing tables

11.Heap

A heap is a specialized tree-based data structure that satisfies the heap property. There are two
types of heaps:

1. Max Heap: For any given node C, if P is a parent node of C, then the key of P is greater than or
equal to the key of C.

2. Min Heap: For any given node C, if P is a parent node of C, then the key of P is less than or equal to
the key of C.

This diagram represents a max heap.

12. Heap Operations

The main operations on a heap are:

1. Insert: Add the element at the bottom, then "bubble up" to its correct position

• Time Complexity: O(log n)

2. Extract Max/Min: Remove the root, replace it with the last element, then "bubble down" to
maintain the heap property

• Time Complexity: O(log n)

3. Peek: Return the maximum (for max heap) or minimum (for min heap) element without removing
it

• Time Complexity: O(1)

4. Heapify: Convert an array into a heap structure

• Time Complexity: O(n)

Applications of Heaps:

1. Priority Queues

2. Dijkstra's algorithm for finding shortest paths in graphs

3. Heap Sort algorithm

4. Finding the k largest/smallest elements in a collection

5. Memory management in operating systems

13. Binomial Heaps

Binomial heaps are a collection of binomial trees that satisfy the heap property. A binomial tree of
order k has 2^k nodes.

Properties:

- Efficient union operation

- Consists of a set of binomial trees

- Each binomial tree follows min-heap or max-heap property

This diagram shows a binomial tree of order 2.

Time Complexity:

- Insert: O(log n) amortized

- Union: O(log n)

- Extract Min: O(log n)

Space Complexity: O(n)

Applications of Binomial Heaps:

1. Priority Queues with efficient merge operations

2. Graph algorithms (e.g., Prim's algorithm for Minimum Spanning Tree)

3. External sorting algorithms

14. Fibonacci Heaps

Fibonacci heaps are a collection of trees that satisfy the min-heap property. They provide better
amortized performance for operations like decrease-key.
Key features:

- Trees can have any shape

- Lazy operations (delayed consolidation)

- Amortized time complexity for decrease-key is O(1)

Operations:

- Insert: O(1)

- Find-min: O(1)

- Delete-min: O(log n) amortized

- Decrease-key: O(1) amortized

Applications of Fibonacci Heaps:

1. Optimizing Dijkstra's algorithm for shortest paths

2. Prim's algorithm for minimum spanning trees

3. Graph algorithms with frequent decrease-key operations

15. Hashing

Hashing is a technique used to map data of arbitrary size to fixed-size values. It's used for efficient
data retrieval and storage.

Components of a Hash Table:

1. Hash Function: Converts keys into array indices

2. Array: Stores the key-value pairs

3. Collision Resolution Method: Handles cases when two keys hash to the same index
Collision Resolution Methods:

1. Chaining: Each array element is a linked list of key-value pairs

2. Open Addressing: Probing for the next available slot (Linear Probing, Quadratic Probing, Double
Hashing)

Performance:

- Average case: O(1) for insert, delete, and search

- Worst case: O(n) when all keys collide

Applications of Hashing:

1. Implementing associative arrays (dictionaries)

2. Database indexing

3. Caching

4. Symbol tables in compilers and interpreters

5. Cryptography (e.g., storing passwords)

6. Blockchain technology
 UNIT-3

1. Representation of Graphs

Graphs are mathematical structures used to model pairwise relations between objects. They consist
of vertices (or nodes) and edges that connect these vertices.

There are two main ways to represent graphs:

a) Adjacency Matrix:

- A 2D array where rows and columns represent vertices

- Matrix[i][j] = 1 if there's an edge from vertex i to j, otherwise 0

- Space complexity: O(V^2), where V is the number of vertices

b) Adjacency List:

- An array of lists, where each list represents the neighbors of a vertex

- Space complexity: O(V + E), where V is the number of vertices and E is the number of edges
2. Graph Traversals

Graph traversals are used to visit all the vertices of a graph in a specific order.

a) Depth-First Search (DFS):

- Explores as far as possible along each branch before backtracking

- Uses a stack (or recursion) to keep track of vertices to visit

- Time complexity: O(V + E)

b) Breadth-First Search (BFS):

- Explores all the neighbors at the present depth before moving to vertices at the next depth level

- Uses a queue to keep track of vertices to visit

- Time complexity: O(V + E)

3. Applications of Graphs

Graphs have numerous applications in computer science and real-world scenarios:

a) Social Networks: Modeling relationships between people

b) Web Crawling: Navigating through web pages and their links

c) GPS and Navigation: Finding shortest paths between locations

d) Recommendation Systems: Suggesting products or content based on user preferences

e) Computer Networks: Modeling network topology and routing

f) Dependency Resolution: Managing software dependencies

g) Compiler Design: Optimizing code execution paths

h) Biological Networks: Modeling protein interactions or ecological food webs

4. Topological Sort

Topological sorting is used for ordering the vertices of a Directed Acyclic Graph (DAG) such that for
every directed edge (u, v), vertex u comes before v in the ordering.

Applications:

- Task scheduling

- Build systems (determining the order of compilation)

- Data serialization

Topological order: A, B, C, D
5. Shortest Path Algorithms

a) Dijkstra's Algorithm:

Purpose: Finds the shortest path from a source node to all other nodes in a weighted graph with
non-negative weights.

- Uses a priority queue to select the next vertex to process

- Time complexity: O((V + E) log V) with a binary heap

Steps:

1. Mark all nodes with infinity (∞) as their tentative distance, except the source node, which is
set to 0.

2. Set the source node as current. Explore all its neighbors.

3. For each neighbor:

o Calculate the tentative distance via the current node.

o If the new distance is smaller, update it.

4. Mark the current node as visited (processed).

5. Move to the next unvisited node with the smallest tentative distance.

6. Repeat until all nodes are processed or the target node is reached.
b) Bellman-Ford Algorithm:

Purpose: Solves the single-source shortest path problem in graphs with both positive and negative
edge weights. It also detects negative weight cycles.

- Can detect negative cycles

- Time complexity: O(VE)

Steps:

1. Initialize the distance to the source as 0 and all other nodes as ∞.

2. Relax all edges (u, v, w) (source, destination, weight) |V|-1 times:

o If dist[u] + w < dist[v], update dist[v] = dist[u] + w.

3. Check for negative weight cycles:

o If further relaxation is possible, a negative cycle exists.

c) Floyd's Algorithm (Floyd-Warshall):

Purpose: Finds shortest paths between all pairs of nodes. Suitable for dense graphs.

- Can handle negative edge weights but not negative cycles

- Time complexity: O(V^3)

Steps:

1. Create a distance matrix, where dist[i][j] represents the weight of the edge from i to j. If no
edge exists, use ∞. Set dist[i][i] = 0.

2. For each node k, update the matrix:

o dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]).

3. Continue until all pairs are processed.

6. Minimum Spanning Tree (MST) Algorithms

A Minimum Spanning Tree is a subset of edges that connects all vertices in a weighted, undirected
graph with the minimum total edge weight.

a) Prim's Algorithm:

- Builds the MST by adding the cheapest edge that connects a vertex in the tree to a vertex outside
the tree

- Uses a priority queue to select the next edge

- Time complexity: O((V + E) log V) with a binary heap

Steps:

1. Start from any vertex (source node).

2. Add the edge with the smallest weight that connects the current MST to a vertex not yet in
the MST.

3. Repeat until all vertices are included in the MST.

b) Kruskal's Algorithm:

- Builds the MST by adding the cheapest edge that doesn't create a cycle

- Uses a disjoint-set data structure to detect cycles

- Time complexity: O(E log E) or O(E log V)

Steps:

1. Sort all edges by weight.

2. Start with an empty MST.

3. Add the smallest edge to the MST if it doesn’t form a cycle (use a union-find structure to
check for cycles).

4. Repeat until the MST has V-1 edges (where V is the number of vertices).
Key Differences between Prim's and Kruskal's Algorithms:

- Prim's starts with a vertex and grows the tree

- Kruskal's starts with edges and builds up disjoint sets

Applications of MST:

- Network design (e.g., laying cable for computer networks)

- Approximation algorithms for NP-hard problems (e.g., Traveling Salesman Problem)

- Cluster analysis in data mining

 UNIT-4

1. Algorithm Analysis and Asymptotic Notations

Algorithm analysis is the process of determining the computational complexity of algorithms - the
amount of time, storage, or other resources needed to execute them.

Asymptotic notations are used to describe the running time of an algorithm. The three main
notations are:

a) Big O Notation (O): Upper bound

b) Omega Notation (Ω): Lower bound

c) Theta Notation (Θ): Tight bound (both upper and lower)

Common time complexities:

- O(1): Constant time

- O(log n): Logarithmic time

- O(n): Linear time

- O(n log n): Linearithmic time

- O(n^2): Quadratic time

- O(2^n): Exponential time

2. Divide and Conquer Algorithms

Divide and Conquer is an algorithm design paradigm that works by recursively breaking down a
problem into two or more sub-problems of the same or related type, until these become simple
enough to be solved directly.

General steps:

1. Divide: Break the problem into smaller sub-problems

2. Conquer: Recursively solve the sub-problems

3. Combine: Combine the solutions of sub-problems to create a solution to the original problem

a) Merge Sort

- Divide: Split the array into two halves

- Conquer: Recursively sort the two halves

- Combine: Merge the sorted halves

Time complexity: O(n log n)

Space complexity: O(n)

b) Quick Sort

- Choose a pivot element

- Partition the array around the pivot

- Recursively sort the sub-arrays

Time complexity:

- Average case: O(n log n)

- Worst case: O(n^2)

Space complexity: O(log n) due to the recursive call stack

c) Binary Search

- Requires a sorted array

- Repeatedly divide the search interval in half

Time complexity: O(log n)

Space complexity: O(1) for iterative, O(log n) for recursive due to call stack
3. Greedy Algorithms

Greedy algorithms make the locally optimal choice at each step with the hope of finding a global
optimum. They are often used for optimization problems.

Characteristics:

- Greedy choice property

- Optimal substructure

Example: Knapsack Problem (Fractional Knapsack)

- Given weights and values of n items, put these items in a knapsack of capacity W to get the
maximum total value in the knapsack.

- Greedy approach: Choose items with the highest value/weight ratio

Time complexity: O(n log n) due to sorting

4. Dynamic Programming

Dynamic Programming is a method for solving complex problems by breaking them down into
simpler subproblems. It is applicable when subproblems overlap and have optimal substructure.

Key aspects:

- Overlapping subproblems

- Optimal substructure

- Memoization or Tabulation

Example: Optimal Binary Search Tree

- Given a sorted array of keys and their frequencies, construct a binary search tree that minimizes the
total search cost.

Steps:

1. Calculate the cost of a subtree

2. Use a 2D table to store costs of different subtrees

3. Fill the table diagonally upwards

Time complexity: O(n^3)

Space complexity: O(n^2)

5. Warshall's Algorithm (Floyd-Warshall Algorithm)

Warshall's algorithm, also known as the Floyd-Warshall algorithm, is used for finding the shortest
paths between all pairs of vertices in a weighted graph with positive or negative edge weights (but
no negative cycles).

Key points:

- Works for both directed and undirected graphs

- Can detect negative cycles

- Uses dynamic programming approach

Steps:

1. Initialize the distance matrix with direct edge weights

2. For each intermediate vertex, update the distance matrix if a shorter path is found through that
vertex

Time complexity: O(V^3), where V is the number of vertices

Space complexity: O(V^2)

 UNIT-5

1. Backtracking

Backtracking is an algorithmic technique that considers searching every possible combination in

order to solve a computational problem. It builds candidates to the solution incrementally and
abandons a candidate ("backtracks") as soon as it determines that the candidate cannot lead to a
valid solution.

Key characteristics:

- Depth-First Search approach

- Pruning of search tree

- Used for solving constraint satisfaction problems

Example: N-Queens Problem

The N-Queens problem is to place N chess queens on an N×N chessboard so that no two queens
threaten each other.

Steps:

1. Start in the leftmost column

2. If all queens are placed, return true

3. Try all rows in the current column

4. For each row, check if the queen can be placed safely

5. If yes, mark the position and recursively check if this leads to a solution

6. If no solution is found, backtrack and try the next row

Time Complexity: O(N!), where N is the number of queens

Space Complexity: O(N) for the recursive call stack

2. Branch and Bound

Branch and Bound is an algorithm design paradigm for discrete and combinatorial optimization
problems. It consists of a systematic enumeration of candidate solutions by means of state space
search.

Key components:

- Branching: Splitting the problem into subproblems

- Bounding: Estimating the best possible solution for each subproblem

- Pruning: Discarding subproblems that cannot lead to a better solution

Example: Assignment Problem

The assignment problem is to find an optimal assignment of n tasks to n workers, minimizing the
total cost.

Steps:

1. Create a cost matrix

2. Compute the lower bound for the root node

3. Branch on the first unassigned task

4. Compute bounds for child nodes

5. Select the node with the lowest bound

6. Repeat steps 3-5 until a complete assignment is found

Time Complexity: O(n!) in the worst case, but typically much better in practice due to pruning

Space Complexity: O(n^2) for the cost matrix and O(n) for the recursive call stack

3. P and NP Problems

P and NP are complexity classes used in computational complexity theory to classify decision
problems.

P (Polynomial Time):

- Problems that can be solved in polynomial time by a deterministic Turing machine

- Examples: Sorting, Searching, Matrix Multiplication

NP (Nondeterministic Polynomial Time):

- Problems that can be verified in polynomial time by a deterministic Turing machine

- All problems in P are also in NP

- Examples: Boolean Satisfiability, Traveling Salesman Problem, Graph Coloring

NP-Complete Problems:

- The hardest problems in NP

- If any NP-complete problem can be solved in polynomial time, then all problems in NP can be
solved in polynomial time (P = NP)

- Examples: Boolean Satisfiability (SAT), Hamiltonian Cycle Problem, Subset Sum Problem

4. Approximation Algorithms for NP-Hard Problems

Approximation algorithms are used to find near-optimal solutions to NP-hard optimization problems
in polynomial time.

Key concepts:

- Approximation ratio: The ratio between the solution found by the algorithm and the optimal
solution

- Performance guarantee: An upper bound on the approximation ratio

Example: Traveling Salesman Problem (TSP)

The TSP is to find the shortest possible route that visits each city exactly once and returns to the
starting city.

Approximation Algorithm: Christofides algorithm

- Guarantees a tour at most 1.5 times the optimal tour length for metric TSP

Steps:

1. Construct a minimum spanning tree (MST)

2. Find a minimum-weight perfect matching on odd-degree vertices

3. Combine the MST and the matching to form an Eulerian graph

4. Construct an Eulerian tour

5. Convert the Eulerian tour to a Hamiltonian cycle by skipping repeated vertices

Time Complexity: O(n^3), where n is the number of cities

Approximation Ratio: 1.5 for metric TSP

5. Amortized Analysis

Amortized analysis is a method of analyzing the time complexity of algorithms that make a sequence
of operations. It provides a way to analyze the average performance of each operation in the worst
case.

Key techniques:

1. Aggregate Method

2. Accounting Method (Banker's Method)

3. Potential Method

Example: Dynamic Array (ArrayList in Java, vector in C++)

Operations:

- add(element): Adds an element to the end of the array

- get(index): Returns the element at the given index

- size(): Returns the number of elements in the array

Amortized Analysis of add() operation:

- When the array is full, we double its size

- Cost of n operations: n + (1 + 2 + 4 + ... + n/2) ≈ 3n

- Amortized cost per operation: 3n / n = 3 = O(1)