Write a C program to implement the following using an array a) Stack ADT b) Queue ADT.

explain its implementation

Here’s a concise explanation and C code for implementing Stack ADT and Queue ADT
using arrays:

Explanation

a) Stack ADT:

 A stack follows the LIFO (Last In, First Out) principle.

 Key operations:

1. Push: Add an element to the top.

2. Pop: Remove an element from the top.

3. Peek: View the top element without removing it.

 Implementation:

o Use an array and a top variable to track the index of the last element.

o Overflow occurs if top == MAX_SIZE - 1.

o Underflow occurs if top == -1.

b) Queue ADT:

 A queue follows the FIFO (First In, First Out) principle.

 Key operations:

1. Enqueue: Add an element to the rear.

2. Dequeue: Remove an element from the front.

3. Peek: View the front element without removing it.

 Implementation:

o Use an array, a front index, and a rear index.

o Circular queue handles wrap-around using (rear + 1) % MAX_SIZE.

Write C Program to implement the DEQUE (double ended queue) ADT using arrays
explain its implementation.
Explanation

A DEQUE (Double-Ended Queue) is a generalized form of a queue that allows:

 Insertion and Deletion at both ends (front and rear).

Types of Deques:

1. Input-Restricted DEQUE: Insertions are allowed only at one end, but deletions
are allowed at both ends.

2. Output-Restricted DEQUE: Deletions are allowed only at one end, but

insertions are allowed at both ends.

Key Operations:

 Insert at Front: Adds an element to the front.

 Insert at Rear: Adds an element to the rear.

 Delete from Front: Removes an element from the front.

 Delete from Rear: Removes an element from the rear.

 Peek Front/Rear: Views elements at front/rear without removing them.

Implementation:

 Array-based Circular DEQUE:

o Use an array, a front index, and a rear index.

o To ensure wrap-around, use (index + 1) % MAX_SIZE for increment and

(index + MAX_SIZE - 1) % MAX_SIZE for decrement.

o Overflow occurs when the next position of rear equals front.

o Underflow occurs when front == -1.

Write a C program to perform the following operations: a) Insert an element into a binary
search tree. b) Delete an element from a binary search tree. c) Search for a key element
in a binary search tree.

Explanation of Operations in a Binary Search Tree (BST)

a) Insertion into a BST:

 A new element is always inserted as a leaf.

  Traverse the tree starting from the root:

o If the value is smaller than the current node, move to the left child.

o If the value is greater, move to the right child.

o Insert the element when a NULL position is found.

 Time Complexity: O(h)O(h)O(h), where hhh is the height of the tree.

b) Deletion from a BST:

 Locate the node to be deleted and handle one of three cases:

1. Node has no children (leaf): Simply remove the node.

2. Node has one child: Replace the node with its child.

3. Node has two children:

 Find the in-order successor (smallest value in the right subtree).

 Replace the node's value with the successor's value.

 Recursively delete the successor.

 Time Complexity: O(h)O(h)O(h).

c) Search in a BST:

 Traverse the tree:

o If the key equals the current node, the search is successful.

o If the key is smaller, search in the left subtree.

o If the key is greater, search in the right subtree.

 Time Complexity: O(h)O(h)O(h).

Write a C program that use recursive functions to traverse the given binary tree in a)
Preorder b) Inorder and c) Postorder.

Explanation of Tree Traversals

A binary tree traversal involves visiting all nodes in a specific order. The three main types
of depth-first traversals are:
 1. Preorder Traversal (Root-Left-Right):

o Visit the root node.

o Recursively traverse the left subtree.

o Recursively traverse the right subtree.

2. Inorder Traversal (Left-Root-Right):

o Recursively traverse the left subtree.

o Visit the root node.

o Recursively traverse the right subtree.

3. Postorder Traversal (Left-Right-Root):

o Recursively traverse the left subtree.

o Recursively traverse the right subtree.

o Visit the root node.

Write a C program for linear search and binary search.

Explanation of Searching Algorithms

1. Linear Search:

o Sequentially check each element in the array until the target element is
found or the array ends.

o Works on both sorted and unsorted arrays.

o Time Complexity: O(n).

2. Binary Search:

o Works only on sorted arrays.

o Repeatedly divides the search interval in half:

 If the target is smaller than the middle element, search in the left
half.

 If the target is larger, search in the right half.

o Time Complexity: O(log n).

Write C programs for the implementation of BFS and DFS for a given graph.

Explanation of BFS and DFS in Graphs

Graph Traversals:

1. Breadth-First Search (BFS):

o Explores all neighbors of a node before moving to the next level of neighbors.
o Uses a queue to keep track of nodes to visit.
o Time Complexity: O(V+E), where VVV is the number of vertices and EEE is
the number of edges.
2. Depth-First Search (DFS):

o Explores as far as possible along each branch before backtracking.

o Uses a stack (either explicit or via recursion).
o Time Complexity: O(V+E).

Write C programs for implementing the following sorting methods: a) Merge Sort b)
Heap Sort.

Explanation of Sorting Algorithms

a) Merge Sort:

 A divide-and-conquer algorithm.
 Splits the array into two halves, recursively sorts each half, and merges them.
 Time Complexity: O(n log n).

b) Heap Sort:

 A comparison-based sorting technique based on a binary heap.

 Builds a max-heap from the array, repeatedly extracts the maximum element,
and adjusts the heap.
 Time Complexity: O(n log n).

Write a C program to implement quick sort.

Quick Sort:

 A divide-and-conquer sorting algorithm.

 Selects a "pivot" element and partitions the array such that:
o Elements smaller than the pivot are on the left.
o Elements larger than the pivot are on the right.
 Recursively applies the process to the left and right subarrays.
 Time Complexity:
o Best/Average Case: O(nlog n)O(n \log n)O(nlogn).
o Worst Case (when the pivot is the smallest or largest element): O(n2).
 Space Complexity: O(log n) for recursive calls.
Write a C program to perform the following operations. a) Insertion into a B-tree b)
Deletion from a B-tree.

Explanation of B-tree Operations

A B-tree is a self-balancing search tree optimized for systems that read and write
large blocks of data. It is widely used in databases and file systems. A B-tree
ensures that:
1. All leaf nodes are at the same depth.
2. The tree remains balanced by enforcing a maximum and minimum number of
keys in each node.

a) Insertion into a B-tree:

 If the target node has space, insert the key directly.

 If the node is full, split it into two nodes:
o Push the middle key up to the parent node.
o Repeat the process recursively if necessary.

c) Deletion from a B-tree:

 If the key is in a leaf node, remove it.

 If the key is in an internal node:
o Replace it with its predecessor (or successor) and delete the
predecessor (or successor).
o Ensure the tree properties are maintained.
 If the target node has fewer keys than the minimum allowed, rebalance the
tree by borrowing from a sibling or merging with a sibling.