SIMPLE Sorting

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


• 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


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


Pivot = 98

right

rightleft

left

left right


Pivot = 98

right

rightleft

left

left right

left right

67 32 45 73 98 101 99

leftright


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, 3,6)pivot (after partition = 3)




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)

SIMPLE Sorting

Documents

Transcript of SIMPLE Sorting