Chapter 7: Sorting

Sorting

Goal: Sort a set of n elements.



Assumption: No element is repeated.



Insertion Sort

• (n-1) passes
• before pass P: elements 1 to P-1 are sorted
• in pass P: move P^th element left until
  correct place found
• after pass P: elements 1 to P are sorted
• Time complexity = $\sum_{P=2}^n P$
  $= 2+3+4+\ldots+n = \Theta(n^2)$

Shellsort

• use increment sequence h_t, $h_{t-1},\ldots,$ h₂, h₁ in that order
• h_k > h_k-1, h₁=1
• after h_k phase, all elements h_k apart are sorted
• h_k-sort = insertion sort on h_k independent sub-arrays
• worst case running time using Shell's
  increments = $\Theta(n^2)$
• Hibbard's increments = $1,~3,~7,\ldots,~2^k-1$
• worst case running time with Hibbard's
  increments = $\Theta(n^{3/2})$

Heapsort

• Build_Heap: O(n) time
• n Delete_Min operations: $n\times O(log~n)$
• Time complexity = O(n log n)

Mergesort

• Recursively:
  • sort [ $a_1,\ldots, a_{n/2}$] and [ $a_{n/2+1},\ldots, a_n$]
  • Merge sorted sub-lists
• T(n) = 2T(n/2) + n
• T(1) = 1
• Therefore, T(n) = O(n log n)

Quicksort

Recursive Solution: Quicksort(S)

1.

pick any element v as pivot

2.

partition

• $S_1=\{x \in S-\{v\} \mid x \leq v\}$
• $S_2=\{x \in S-\{v\} \mid x \geq v\}$

3.

return {Quicksort(S₁,), v, Quicksort(S₂)}

Base Case: if $\mid S \mid = 0$, or 1, return {S}

• subproblems may not be of equal size
• partitioning can be performed in place and efficiently

Picking the pivot

• choosing first element as pivot $\Rightarrow$
  inefficient for presorted or partially sorted input
• random choice of pivot: acceptable
• median of left, right and center elements $\Rightarrow$ eliminates the bad case of sorted input.

Quicksort: Time Complexity

T(n) = T(i) + T(n-i-1) + cn

T(0) = 1

Worst Case:

pivot is always the smallest
element
T(n) = O(n²)

Best Case:

equal partitions
T(n) = 2 T(n/2) + cn
T(n) = O(n log n)

Average Case:

each size of S₁ is equally likely
$T(n) = \frac{2}{n}(\sum_{j=0}^{n-1} T(j)) + cn$
T(n) = O(n log n)

Quickselect(S₁, k)

Select k^th smallest element from S

1.

pick pivot $v \in S$

2.

partition $S-\{v\}$ into S₁ and S₂

3.

if $k\leq \mid S_1 \mid$, Quickselect(S₁, k)

4.

if $k = \mid S_1 \mid + 1$, return(pivot)

5.

otherwise, Quickselect(S₂, $k-\mid S_1 \mid -1$)

• Quickselect makes only one recursive call (not two)
• worst case = O(n²)
• average case = O(n)

Sorting Large Objects

• swapping large objects is expensive
• swap pointers to objects, instead
• indirect sorting

External Sorting

• main memory is directly addressable
• secondary memory is not
• e.g., tape = sequential access
• non-sequential data access
  $\Rightarrow$ increased execution time
• alleviate problem by using additional tapes