SIMPLE Sorting
• Sorting is a typical operation to put the elements in an array in order.
• Internal Sorts [for small data sets]selectionbubble (exchange)
• External Sorts [for large data sets]
Selection Sort index (k) sm_index
0 2swap 21, 9
1 1swap 13, 13
2 3swap 21, 15
3 4swap 21, 17
21 159 13 17
15 179 13 21
99 152121 13 17
15 21219 13 1717
2121 15159 13 17
Find smallest element, andput at the head of the list,repeatwith remainder of list
Selection Sort
void sort(double [5]);void swap(double [5], int, int); // prototypes
void main(void){ int index;
double my_list[ ] = {21, 13, 9, 15, 17};
sort(my_list); // function call
cout<<"\nThe sorted array is: \n";for(index=0; index<5; index++)
cout<<'\t'<<my_list[index]<<endl;}
Selection Sortvoid sort(double testArray[5]){ int n, k, sm_index, moves=0; double smallest;
for(k=0; k<4; k++) // size-1 = number of passes{ smallest=testArray[k];
sm_index=k;for(n=k+1; n<5; n++) // size = # elem. to look at
if(testArray[n]<smallest){ smallest=testArray[n];
sm_index=n;}
swap(testArray, sm_index, k); // call to swap()}
}
Bubble Sort
• Put smaller first
• Put smaller first
• No change
• Put smaller first21 252513 9 1717
2121 252513 9 17
99 252121 13 17
9 2513 21 17
Bubble Sort
• Begin again and put smaller first
• No change
• Put smaller first
21 179 13 25
17 21219 13 2525
2121 171313 9 25
2121 17179 13 25
A Bubble Sort Functionvoid bubble_sort(int array[ ], int length){
int j, k, flag=1, temp;for(j=1; j<=length && flag; j++){
flag=0; // falsefor(k=0; k < (length-j); k++){
if (array[k+1] > array[k]) // > low to high{
temp=array[k+1]; // swaparray[k+1]= array[k];array[k]=temp;flag=1; // indicates a swap
}} }} }} }} // has occurred
Insertion sort:
Pick up the cards one at a time. When a card is picked up put it in the “already picked up list” in its correct position.
*
G D Z F B E0 1 2 3 4 5 Index number
G D Z F B E0 1 2 3 4 5
D G Z F B E0 1 2 3 4 5
D G Z F B E0 1 2 3 4 5
D F G Z B E0 1 2 3 4 5
B D F G Z E0 1 2 3 4 5
B D E F G Z0 1 2 3 4 5
InsertionSort( int a[], int n){int I; loc; temp;
for (I = 1; I < n; I++) { temp = a[I]; loc = I;
while (loc && (a[loc-1] > temp)) { a[loc] = a[loc-1]; -- loc; } a[loc] = temp;
}
GET NEXT ELEMENT TO INSERT
Find its place in list -- keepmoving items down until thecorrect locations is found
Insertion Sort
Analysis:
Worst case: O(n2)1+2+3+4+5….comparisons and moves
for (I = 1; I < n; I++) { temp = a[I]; loc = I;
while (loc && (a[loc-1] > temp)) { a[loc] = a[loc-1]; -- loc; } a[loc] = temp;
BEST CASE?
*
O(n)
Good for mostly sortedlists
Average case = O(n2)
Using Pointers for Sorting
In the algorithms looked at the data is physically re-arranged
Quicksort algorithm
• Split list into two “halves” one greater than the other
• now split each of these two lists
Elements…………..
jLess than j Greater than j
e s
< e >e <s >s
c g m w
<c >c <g >g <m >m <w >w
a b c d eD f F g h ji k l m o sq u v w y z
Partition
• Divide the list into two halves: left and right where the left half is smaller than the right:
• ----> use a “pivot” elements less than the pivot go left, elements greater than the pivot go right
98 32 45 99 101 73 67 Pivot = 98
rightleft
Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.
Pivot = 98
right
left rightleft left
left
Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.
Pivot = 98
right
rightleft
left
left right
Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.
Pivot = 98
right
rightleft
left
left right
left right
67 32 45 73 98 101 99
leftright
Invariant: elements to the left of “left” are smaller, and to the right of “right” are bigger.
int partition(int num[], int left, int right){int pivot_val, temp;Pivot_val = num[left]; // "capture" the pivot value, which frees up one slot while (left < right) { // scan from right to left while(num[right] >= pivot_val && left < right) // skip over larger or equal val
right--; if (right != left) { num[left] = num[right]; // move the higher value left++; } // scan from left to right while (num[left] <= pivot_val && left < right) // skip over smaller or equal val
left++; if (right != left) { num[right] = num[left]; // move lower value into the available slot
right--; } } num[left] = pivot_val; // move pivot into correct position return left; } // return the pivot index
#include <iostream>using namespace std;int partition(int [], int, int); // function prototype
int main(){ const int NUMEL = 7; int nums[NUMEL] = {98,32,45,99,101,73,67}; int i, pivot; pivot = partition(nums, 0, NUMEL-1); cout << "\nThe returned pivot index is " << pivot; cout << "\nThe list is now in the order:\n"; for (i = 0; i < NUMEL; i++) cout << " " <<nums[i]; cout << endl; return 0;}
The pivot index is 4the list is now in the order:67 32 45 73 98 101 99
*
Quicksort algorithm must call the partition algorithmuntil the “list is sorted”, I.e. on each half recursively until the “halves” are too small
Quicksort algorithm:
pick pivot & partition list call quicksort(left half) call quicksort (right half)
Elements…………..
Quicksort(left) Quicksort(right)jLess than j Greater than j
Q(left/left) Q(left/rgt)e Q(rgt/left) Q(rgt/rgt)s
< e >e <s >s
c g m w
<c >c <g >g <m >m <w >w
a b c d eD f F g h ji k l m o sq u v w y z
14 calls to Quicksort
Pivot = 98
right
left rightleft left
left
left right
left right
67 32 45 73 98 101 99leftright
After the partitionwith the pivot=9898 is in its final position
67 32 45 73 98 101 99
45 32 67 73 98 99 101
32 45
Result of 1st partition
2nd and 3rd partition
4th partition
void quicksort(int num[], int lower, int upper){ int i, j, pivot;
pivot = partition(num,lower, upper);
if (lower < pivot) quicksort(num, lower, pivot - 1); if (upper > pivot) quicksort(num, pivot + 1, upper);
return;}
#include <iostream>using namespace std;void quicksort(int [], int, int); // function prototypesint partition(int [], int, int);int main(){ const int NUMEL = 7; int nums[NUMEL] = {67,32,45,73,98,101,99}; int i; quicksort(nums, 0, NUMEL-1); cout << "\nThe sorted list, in ascending order, is:\n"; for (i = 0; i < NUMEL; i++) cout << " " <<nums[i]; cout << endl;return 0;}
Quicksort(nums, 0, 6)pivot (after partition = 2)
Quicksort(nums, 0, 1)pivot (after partition = 1)
Quicksort(nums, 0, 0)pivot (after partition = 0)
Quicksort(nums, 3,6)pivot (after partition = 3)
Quicksort(nums, 4,6)pivot (after partition = 4)
Quicksort(nums, 5,6)pivot (after partition = 6)
Quicksort(nums, 5,5)pivot (after partition = 5)
67 32 45 73 98 101 9945 32 67 73 98 101 99
45 3232 45
32 73 98 101 99
98 101 99
101 9999 101
99
IN CLASS Assignment:
Given the list of numbers below, write out thesteps for the quicksort algorithm:
12 14 3 6 56 2 10 25 89 8
12 14 3 6 56 2 10 25 89 8
8 10 3 6 2 12 56 25 89 14
Piv=12
2 6 3 8 10 12 14 25 56 89
Piv=8 Piv=56
Piv=2 Piv=14
2 6 3 8 10 12 14 25 56 89
2 3 6 8 10 12 14 25 56 89
Piv=6
Analysis of Quicksort:
void quicksort(int num[], int lower, int upper){ int i, j, pivot;
pivot = partition(num,lower, upper);
if (lower < pivot) quicksort(num, lower, pivot - 1); if (upper > pivot) quicksort(num, pivot + 1, upper);
Takes O(upper-lower) sinceevery element must be comparedto the pivot
Time(Quicksort(n)) = Partition(n) + Quicksort(n/2)+Quicksort(n/2)
Best case time:
O(n)
Partition(n/2) + Quicksort(n/4) + Quicksort(n/4) +Partition(n/2) + Quicksort(n/4) + Quicksort(n/4)
= O(n) + 2*O(n/2) + 4*(Quicksort(n/4) …
= O(n) + O(n) + O(n) Log(n) times…..
= O(nlogn)
Worst case time:
1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10
N times
= O(n2)