Merge Sort Algorithm and Recursion Trees

Lecture 8 of CS502 Fundamentals of Algorithms presents a deep examination of the classic merge sort algorithm and its recurrence analysis. Merge sort exemplifies divide-and-conquer: given an unsorted array of n elements, the divide step computes the midpoint index and splits the sequence into two equal sub-arrays of size n/2. The conquer step recursively sorts each half. The combine step merges the two sorted sub-arrays into a single sorted array using a linear-time two-way Merge procedure that compares front elements and copies the smaller item into an auxiliary buffer. The recurrence relation governing merge sort is formulated as T(n) = 2T(n/2) + Theta(n) for n > 1, with T(1) = Theta(1). To solve this recurrence visually, the lecture constructs a recursion tree. At depth i, there are 2^i subproblems each of size n/2^i, contributing a total work of 2^i * c*(n/2^i) = cn per level. Since the tree reaches a height of log2(n) levels, multiplying the uniform work per level by the tree depth yields an exact total running time of Theta(n log n). Students investigate the trade-offs between divide-and-conquer strategies, greedy choice properties, and dynamic programming formulations. The discussion highlights how mathematical induction and structural invariants provide formal verification of algorithmic termination and correctness. Key concepts such as optimal substructure, overlapping subproblems, and memoization tables are thoroughly demystified. The lecture details classical algorithmic design techniques demonstrated across standard benchmark problems in computer science. Structured recurrence solving methodologies are demonstrated using the substitution method, recursion tree analysis, and the Master theorem. Algorithmic decision boundaries and lower-bound complexity proofs are evaluated alongside practical runtime performance characteristics. Graph representations are explored through adjacency matrices, adjacency lists, and memory footprint considerations in sparse and dense topologies. Breadth-first and depth-first search mechanics, discovery and finishing timestamps, and edge classifications are systematically analyzed. Greedy strategies including Huffman prefix tree generation and activity scheduling are rigorously proven using exchange arguments. Scholars examine shortest path optimality conditions, edge relaxation properties, and negative cycle detection algorithms.