CS 46B - Lecture 11

Pre-class reading

• Sections 14.4-14.5

Merge Sort

• Sorts an array by
  • Cutting the array in half
  • Recursively sorting each half
  • Merging the sorted halves
• Dramatically faster than the selection sort

Merge Sort Example

• Divide an array in half and sort each half
  
• Merge the two sorted arrays into a single sorted array

Merge Sort

public void sort()
{
   if (a.length <= 1) return;
   int [] first = new int[a.length / 2];
   int[] second = new int[a.length - first.length];
   // Copy the first half of a into first, the second half into second 
   . . .
   MergeSorter firstSorter = new MergeSorter(first);
   MergeSorter secondSorter = new MergeSorter(second);
   firstSorter.sort();
   secondSorter.sort();
   merge(first, second);
}

Lecture 11 Clicker Question 1

Look at the first while loop of the merge method. Which of the following is true when the loop is complete?

1. All elements of first have been added to a
2. All elements of second have been added to a
3. All elements of first or second have been added to a
4. Both first and second contain some elements that haven't been added to a

Lecture 11 Clicker Question 2

Consider the merge method, and assume that a has n elements. What is the big-Oh efficiency of the merge method?

1. O(1)
2. O(n)
3. O(n log n)
4. O(n²)

Analyzing the Merge Sort Algorithm

Merge Sort Timing vs. Selection Sort

Analyzing the Merge Sort Algorithm

• In an array of size n, count how many times an array element is visited
• Assume n is a power of 2: n = 2^m
• Calculate the number of visits to create the two sub-arrays and then merge the two sorted arrays
  • 3 visits to merge each element or 3n visits
  • 2n visits to create the two sub-arrays
  • total of 5n visits

Analyzing the Merge Sort Algorithm

• Let T(n) denote the number of visits to sort an array of n elements then
  • T(n) = T(n/2) + T(n/2) + 5n or
  • T(n) = 2T(n/2) + 5n
• The visits for an array of size n/2 is: T(n/2) = 2T(n/4) + 5n/2
  • So T(n) = 2 × 2T(n/4) +5n + 5n
• The visits for an array of size n/4 is: T(n/4) = 2T(n/8) + 5n/4
  • So T(n) = 2 × 2 × 2T(n/8) + 5n + 5n + 5n

Analyzing Merge Sort Algorithm

• Repeating the process k times: T(n) = 2^kT(n/2^k) +5nk
• Since n = 2^m, when k=m: T(n) = 2^mT(n/2^m) +5nm
• T(n) = nT(1) +5nm
• T(n) = n + 5nlog₂(n)

Analyzing Merge Sort Algorithm

• To establish growth order
  • Drop the lower-order term n
  • Drop the constant factor 5
  • Drop the base of the logarithm since all logarithms are related by a constant factor
  • We are left with n log(n)
• Using big-Oh notation: number of visits is O(n log(n))

Merge Sort Vs Selection Sort

• Selection sort is an O(n²) algorithm
• Merge sort is an O(nlog(n)) algorithm
• The n log(n) function grows much more slowly than n²

Lecture 11 Clicker Question 3

1. With selection sort and merge sort, the longer array takes 1000 times as long as with the original array.
2. With selection sort and merge sort, the longer array takes 1,000,000 times as long as with the original array.
3. With selection sort, the longer array takes 1,000,000 times as long, but with merge sort, it takes about the same time as with the original array
4. With selection sort, the longer array takes 1,000,000 times as long, but with merge sort, it takes about 10,000  the same time as with the original array

The Quicksort Algorithm

• Divide and conquer
  1. Partition the range
  2. Sort each partition
     

The Quicksort Algorithm

public void sort(int from, int to)
{
   if (from >= to) return; 
   int p = partition(from, to);
   sort(from, p);
   sort(p + 1, to); 
}

The Quicksort Algorithm

The Quicksort Algorithm

private int partition(int from, int to)
{
   int pivot = a[from]; 
   int i = from - 1;
   int j = to + 1;
   while (i < j)
   { 
      i++;
      while (a[i] < pivot) i++;
      j--;
      while (a[j] > pivot) j--; 
     if (i < j) swap(i, j);  
   }
   return j;
}