1. SIMPLE Sorting
Sorting is a typical operation to put the elements in an array in order.
Internal Sorts [for small data sets] selection bubble (exchange)
External Sorts [for large data sets]

2. Selection Sort 0 2 swap 21, 9 1 1 swap 13, 13 2 3 swap 21, 15
Find smallest element, and
put at the head of the list,repeat
with remainder of list
Selection Sort
index (k) sm_index
swap 21, 9
swap 13, 13
swap 21, 15
swap 21, 17 21 15 9 13 17

3. 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; }

4. Selection Sort void 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()

5. Bubble Sort 21 25 13 9 17
Put smaller first
No change

6. Bubble Sort Begin again and put smaller first No change21 17 9 13 25
Begin again and put smaller first
No change
Put smaller first

7. A Bubble Sort Function void bubble_sort(int array[ ], int length) {
int j, k, flag=1, temp;
for(j=1; j<=length && flag; j++)
flag=0; // false
for(k=0; k < (length-j); k++)
if (array[k+1] > array[k]) // > low to high
temp=array[k+1]; // swap
array[k+1]= array[k];
array[k]=temp;
flag=1; // indicates a swap
} } } } // has occurred

8. 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. *

9. G D Z F B E
Index number
G D Z F B E
D G Z F B E
D G Z F B E
D F G Z B E
B D F G Z E
B D E F G Z

10. 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 -- keep
moving items down until the
correct locations is found

11. Insertion Sort Analysis: Worst case: O(n2) O(n) BEST CASE?
….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;
O(n)
Good for mostly sorted
lists
Average case = O(n2)
BEST CASE? *

12. Using Pointers for Sorting
In the algorithms looked at the data is physically re-arranged

13. Quicksort algorithm
Split list into two “halves” one greater than the other
now split each of these two lists

14. Elements………….. j
Less than j
Greater than j e s
<s
>s
< e
>e m c g w
<c >c <g >g <m >m <w >w a b c d D e f F g h i j k l m o q s u v w y z

15. 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

16. left
right
Pivot = 98
left
left
left
right
left
right
left
right
left
right

17. int partition(int num[], int left, int right)
{int pivot, temp;
pivot = num[left]; // "capture" the pivot value, which frees up one slot
while (left < right) { // scan from right to left
while(num[right] >= pivot && 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 && left < right) // skip over smaller or equal val
left++;
{ num[right] = num[left]; // move lower value into the available slot
right--; } }
num[left] = pivot; // move pivot into correct position
return left; } // return the pivot index

18. #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 4
the list is now in the order: *

19. Quicksort algorithm must call the partition algorithm
until 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)

20. Elements…………..
Quicksort(left) j
Quicksort(right)
Less than j
Greater than j
Q(left/left) e
Q(left/rgt)
Q(rgt/left) s
Q(rgt/rgt)
<s
>s
< e
>e m c g w
<c >c <g >g <m >m <w >w a b c d D e f F g h i j k l m o q s u v w y z
14 calls to Quicksort

21. left
right
Pivot = 98
left
left
left
right
left
right
left
right
After the partition
with the pivot=98
98 is in its final
position
right
left

22.
Result of 1st partition
2nd and 3rd partition
4th partition
32 45

23. 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; }

24. #include <iostream>
using namespace std;
void quicksort(int [], int, int); // function prototypes
int 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; }

25. Quicksort(nums, 0, 6)
pivot (after partition = 2)
Quicksort(nums, 0, 1)
pivot (after partition = 1)
45 32
32 45
Quicksort(nums, 0, 0)
pivot (after partition = 0) 32
Quicksort(nums, 3,6)
pivot (after partition = 3)
Quicksort(nums, 4,6)
pivot (after partition = 4)
101 99
99 101
Quicksort(nums, 5,6)
pivot (after partition = 6) 99
Quicksort(nums, 5,5)
pivot (after partition = 5)

26. IN CLASS Assignment:
Given the list of numbers below, write out the
steps for the quicksort algorithm:

27.
Piv=12
Piv=8
Piv=56
Piv=2
Piv=14
Piv=6

28. 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) since
every element must be compared
to the pivot

29. Best case time:
Time(Quicksort(n)) = Partition(n) + Quicksort(n/2)+Quicksort(n/2)
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)

30. Worst case time:
N times
= O(n2)