GATE-CS-2005 | Chapter 58

Introduction

Chapter 58 of GATE-CS-2005 is a comprehensive guide to data structures and algorithms. The chapter covers a wide range of topics, including sorting algorithms, trees, heaps, graphs, and dynamic programming. This chapter is a must-read for any programmer who wants to improve their data structure and algorithm skills.

Sorting Algorithms

The chapter starts with a discussion of various sorting algorithms such as Bubble Sort, Insertion Sort, Selection Sort, Merge Sort, and Quick Sort. The author explains how to implement each of these algorithms, their time complexity, and their advantages and disadvantages.

// Quick Sort Implementation in Java
public static void quickSort(int[] arr, int start, int end) {
    if (start < end) {
        int pIndex = partition(arr, start, end);
        quickSort(arr, start, pIndex - 1);
        quickSort(arr, pIndex + 1, end);
    }
}

public static int partition(int[] arr, int start, int end) {
    int pivot = arr[end];
    int pIndex = start;
    for (int i = start; i < end; i++) {
        if (arr[i] <= pivot) {
            int temp = arr[i];
            arr[i] = arr[pIndex];
            arr[pIndex] = temp;
            pIndex++;
        }
    }
    int temp = arr[pIndex];
    arr[pIndex] = arr[end];
    arr[end] = temp;
    return pIndex;
}

Trees

The chapter then introduces the concept of trees, including binary trees, binary search trees, AVL trees, and B-trees. The author explains the key aspects of each type of tree, their properties, and how to implement them.

# Binary Search Tree Implementation in Python
class Node:
    def __init__(self, val):
        self.value = val
        self.leftChild = None
        self.rightChild = None

class BinarySearchTree:
    def __init__(self):
        self.root = None

    def insert(self, val):
        if not self.root:
            self.root = Node(val)
        else:
            self._insert(val, self.root)

    def _insert(self, val, node):
        if val < node.value:
            if not node.leftChild:
                node.leftChild = Node(val)
            else:
                self._insert(val, node.leftChild)
        else:
            if not node.rightChild:
                node.rightChild = Node(val)
            else:
                self._insert(val, node.rightChild)

Heaps

The chapter then moves on to heaps, including binary heaps and priority queues. The author explains how to implement heap operations such as inserting, deleting, and sorting elements in a heap.

// Binary Heap Implementation in C++
class BinaryHeap {
    private:
        vector<int> heap;
        int leftChild(int parent);
        int rightChild(int parent);
        int parent(int child);
        void heapifyUp(int index);
        void heapifyDown(int index);
    public:
        BinaryHeap();
        void insert(int element);
        void deleteMin();
        int getMin();
        bool isEmpty();
        int size();
        void printHeap();
};

void BinaryHeap::heapifyDown(int index) {
    int minChild = leftChild(index);
    if (minChild > 0 && rightChild(index) > 0 && heap[rightChild(index)] < heap[minChild]) {
        minChild = rightChild(index);
    }
    if (minChild > 0 && heap[index] > heap[minChild]) {
        int tmp = heap[index];
        heap[index] = heap[minChild];
        heap[minChild] = tmp;
        heapifyDown(minChild);
    }
}

Graphs

The chapter then covers various types of graphs, including directed, undirected, weighted, and unweighted graphs. The author explains how to represent graphs, traverse graphs using various algorithms such as Depth-First Search and Breadth-First Search, and how to implement graph algorithms such as Dijkstra's algorithm.

// Depth First Search (DFS) Traversal of Graph in JavaScript
function traverseDFS(vertex, visited) {
  visited[vertex] = true;
  console.log(vertex);

  for (let i = 0; i < this.adjList.get(vertex).length; i++) {
    const child = this.adjList.get(vertex)[i];
    if (!visited[child]) {
      traverseDFS(child, visited);
    }
  }
};

// Graph representation in JavaScript using Adjacency List
class Graph {
  constructor() {
    this.vertices = [];
    this.adjList = new Map();
  }

  addVertex(vertex) {
    this.vertices.push(vertex);
    this.adjList.set(vertex, []);
  }

  addEdge(vertexOne, vertexTwo) {
    this.adjList.get(vertexOne).push(vertexTwo);
    this.adjList.get(vertexTwo).push(vertexOne);
  }
}

Dynamic Programming

Finally, the chapter concludes with a discussion of dynamic programming, including the key concepts of memoization and tabulation. The author explains how dynamic programming can be used to solve various problems and provides examples of dynamic programming solutions to real-world problems.

# Fibonacci Series using Dynamic Programming in Python
def fibonacci(n):
    memo = {}
    if n <= 1:
        return n

    if n not in memo:
        memo[n] = fibonacci(n - 1) + fibonacci(n - 2)

    return memo[n]

Overall, the GATE-CS-2005 | Chapter 58 is an excellent resource for any programmer looking to improve their data structure and algorithm skills. The chapter covers a wide range of topics and provides clear and concise explanations along with code examples in various programming languages.