Scribd
Upload
38 views18 pages

Partitioning: - Partitioning Can Be Tricky, Here Is One Method That Works Well

The document describes the quicksort and merge sort algorithms. Quicksort works by picking a pivot element and partitioning the array around it, recursively sorting the subarrays. The best case runtime is O(n log n) but it can degrade to O(n^2) if the pivot is chosen poorly. Merge sort works by dividing the array into single elements, merging pairs to form sorted runs, and merging those runs together. Like quicksort, merge sort has a best, average, and worst case runtime of O(n log n).

Uploaded by

Anonymous 3q6HiK
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
38 views18 pages

Partitioning: - Partitioning Can Be Tricky, Here Is One Method That Works Well

The document describes the quicksort and merge sort algorithms. Quicksort works by picking a pivot element and partitioning the array around it, recursively sorting the subarrays. The best case runtime is O(n log n) but it can degrade to O(n^2) if the pivot is chosen poorly. Merge sort works by dividing the array into single elements, merging pairs to form sorted runs, and merging those runs together. Like quicksort, merge sort has a best, average, and worst case runtime of O(n log n).

Uploaded by

Anonymous 3q6HiK
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 18

Partitioning

<p p p

Partitioning can be tricky, here is one method that works well:


1. Select a pivot, and exchange it with the last element 2. Set i to the first element, and j to the next-to-last element 3. While i < j increment i until an element >= the pivot is found decrement j until an element <= the pivot is found if i < j, swap the elements 4. Exchange the pivot with the element at i

9/10/2003

CS2 - Quicksort

Partitioning

97 17 37

12 46 10 55 80 42 39

Pick pivot == 37

9/10/2003

CS2 - Quicksort

Partitioning

97 17 39

12 46 10 55 80 42 37

Step 1: Move pivot to end of array

9/10/2003

CS2 - Quicksort

Partitioning

97 17 39

12 46 10 55 80 42 37

Step 1: Move pivot to end of array

9/10/2003

CS2 - Quicksort

Partitioning
i j

97 17 39

12 46 10 55 80 42 37

Step 2: set i == 0 and j == array.length - 1

9/10/2003

CS2 - Quicksort

Partitioning
i j

97 17 39

12 46 10 55 80 42 37

Step 3: move i left until value larger than the pivot is found

9/10/2003

CS2 - Quicksort

Partitioning
i j

97 17 39

12 46 10 55 80 42 37

Step 4: move j right until value less than the pivot is found

9/10/2003

CS2 - Quicksort

Partitioning
i j

10 17 39

12 46 97 55 80 42 37

Step 5: swap elements at positions i and j

9/10/2003

CS2 - Quicksort

Partitioning
i j

10 17 39

12 46 97 55 80 42 37

Step 6: move i left until value larger than the pivot is found

9/10/2003

CS2 - Quicksort

Partitioning
i j

10 17 39

12 46 97 55 80 42 37

Step 7: move j right until value less than the pivot is found

9/10/2003

CS2 - Quicksort

10

Partitioning
i j

10 17 12

39 46 97 55 80 42 37

Step 8: swap elements at positions i and j

9/10/2003

CS2 - Quicksort

11

Partitioning
i j

10 17 12

39 46 97 55 80 42 37

Step 9: move i left until it hits j

9/10/2003

CS2 - Quicksort

12

Partitioning
i j

10 17 12

37 46 97 55 80 42 39

Step 10: put pivot in correct spot

9/10/2003

CS2 - Quicksort

13

Partitioning
pivot

10 17 12 < pivot

37 46 97 55 80 42 39 pivot

9/10/2003

CS2 - Quicksort

14

Partitioning
public static void partition( int numbers[], int lo, int hi ) { int i = lo + 1, j = hi, pivot = numbers[lo]; while ( i < j ) { while ( numbers[i] < pivot ) i++; while ( numbers[j] > pivot ) j++; if ( i <= j ) { int tmp = numbers[i]; numbers[i] = numbers[j]; numbers[j] = tmp; } } numbers[0] = numbers[i]; numbers[i] = pivot; return i; }
9/10/2003 CS2 - Quicksort 15

Quicksort
The quicksort algorithm (S is the array of elements to be sorted):
1. If the length of S is 0 or 1, return 2. Pick any element p in S; this is the pivot 3. Partition S (by rearranging its elements) into two subsets: S1, containing all elements of S-p which are < p S2, containing all elements of S-p which are >= p 4. Return quicksort(S1) followed by p, followed by quicksort(S2)

Selecting the pivot wisely can significantly improve the performance of the algorithm
9/10/2003 CS2 - Quicksort 16

Selecting the Pivot


Pivot = First Element
simple, but often the worst possible choice. Consider what happens if the array is already sorted

Pivot = Random Element


safe is almost all situations, however, calculating a random number can be costly

Pivot = Median Value


optimal, but impractical to implement

Pivot = Median of three


a compromise, gives reasonably good performance
9/10/2003 CS2 - Quicksort 17

Analysis
n

n n/2 n/4 n/8 n/8 n/8 n/4 n/8 n/8 n/4 n/8 n/8 n/2 n/4 n/8
log2n

Best Case Complexity nlog2n

9/10/2003

CS2 - Quicksort

18

Analysis
n

n n-1 n-2 n-3 3 2 1 Worst Case Complexity n2


9/10/2003 CS2 - Quicksort 19

Merging
Merging two sorted arrays into a single sorted array is straight forward
1. Set i and j to 0 2. While i < array1.length and j < array2.length 3. If array1[i]<array2[j] then copy array1[I] to the new array and increment i otherwise, copy array2[j] to the new array and increment j 4. Copy the rest of the non-empty array to the new array

9/10/2003

CS2 - Quicksort

20

10

Merging
i 2 3 8 j 3 4 6 7

k
9/10/2003 CS2 - Quicksort 21

Merging
i 2 3 8 j 3 4 6 7

k
9/10/2003 CS2 - Quicksort 22

11

Merging
i 2 3 8 j 3 4 6 7

k
9/10/2003 CS2 - Quicksort 23

Merging
i 2 3 8 3 j 4 6 7

k
9/10/2003 CS2 - Quicksort 24

12

Merging
i 2 3 8 3 j 4 6 7

k
9/10/2003 CS2 - Quicksort 25

Merging
i 2 3 8 3 4 j 6 7

k
9/10/2003 CS2 - Quicksort 26

13

Merging
i 2 3 8 3 4 6 j 7

k
9/10/2003 CS2 - Quicksort 27

Merging
i 2 3 8 3 4 6 7 j

k
9/10/2003 CS2 - Quicksort 28

14

Merging
i 2 3 8 3 4 6 7 j

k
9/10/2003 CS2 - Quicksort 29

Merge Sort
2 2 2 2 97 97 97 17 39 97 17 39 17 39 17 39 39
9/10/2003

12 46 10 55 80 42 37 12 12 12 12
CS2 - Quicksort

46 10 55 80 42 37 46 10 55 46 10 55 10 55 80 42 37 80 42 42 37 37
30

15

Merge Sort
2 2 2 2 97 97 97 17 39 97 17 39 17 39 17 12 12 12 46 10 55 80 42 37 46 10 55 80 42 37 46 10 55 46 10 55 10 55 80 42 37 80 37 42 42 37
31

12 39 39 12

9/10/2003

CS2 - Quicksort

Merge Sort
2 2 2 2 97 97 97 17 39 97 17 39 12 17 17 12 39 12 46 10 55 80 42 37 46 10 55 80 42 37 10 46 46 55 37 42 80 37 42 80 42 37
32

12 39 39 12

10 55 10 55

9/10/2003

CS2 - Quicksort

16

Merge Sort
2 2 2 2 97 97 97 17 39 12 17 39 12 17 17 97 39 12 46 10 55 80 42 37 10 37 42 46 55 80 10 46 46 55 37 42 80 37 42 80 42 37
33

12 39 39 12

10 55 10 55

9/10/2003

CS2 - Quicksort

Merge Sort
2 2 2 2 97 97 10 12 17 12 17 39 12 17 17 97 39 37 39 42 46 55 80 97 10 37 42 46 55 80 10 46 46 55 37 42 80 37 42 80 42 37
34

12 39 39 12

10 55 10 55

9/10/2003

CS2 - Quicksort

17

Analysis
n

n n/2 n/4 n/8 n/8 n/8 n/4 n/8 n/8 n/4 n/8 n/8 n/2 n/4 n/8
log2n

Complexity nlog2n

9/10/2003

CS2 - Quicksort

35

18

You might also like