Sorting techniques Anil Dutt

C-Programming----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Sorting

TOPICS TO BE COVERED

Introduction to Sorting Bubble Sort

Selection Sort Insertion Sort

Sorting

Sorting…… A fundamental application for computers Done to make finding data (searching)

faster Many different algorithms for sorting One of the difficulties with sorting is

working with a fixed size storage container (array) if resize, that is expensive (slow)

The "simple" sorts run in quadratic time O(N2) bubble sort selection sort insertion sort

4

Sorting…… To arrange a set of items in sequence. It is estimated that 25~50% of all

computing power is used for sorting activities.

Possible reasons: Many applications require sorting; Many applications perform sorting when

they don't have to; Many applications use inefficient sorting

algorithms.

Sorting Applications To prepare a list of student ID, names, and

scores in a table (sorted by ID or name) for easy checking.

To prepare a list of scores before letter grade assignment.

To produce a list of horses after a race (sorted by the finishing times) for payoff calculation.

To prepare an originally unsorted array for ordered binary searching.

Bubble Sort

http://www.youtube.com/watch?v=k4RRi_ntQc8

Bubble Sort…… Bubble sort examines the array from start

to finish, comparing elements as it goes. Any time it finds a larger element before a smaller

element, it swaps the two. In this way, the larger elements are passed towards

the end. The largest element of the array therefore

"bubbles" to the end of the array. Then it repeats the process for the unsorted portion

of the array until the whole array is sorted.

Bubble Sort…… Bubble sort works on the same general

principle as shaking a soft drink bottle. Right after shaking, the contents are a mixture

of bubbles and soft drink, distributed randomly. Because bubbles are lighter than the soft

drink, they rise to the surface, displacing the soft drink downwards.

This is how bubble sort got its name, because the smaller elements "float" to the top, while

the larger elements "sink" to the bottom.

"Bubbling Up" the Largest Element

Traverse a collection of elements Move from the front to the end “Bubble” the largest value to the end using

pair-wise comparisons and swapping

512354277 101

1 2 3 4 5 6




512354277 101

1 2 3 4 5 6

Swap42 77




512357742 101

1 2 3 4 5 6

Swap35 77




512773542 101

1 2 3 4 5 6

Swap12 77




577123542 101

1 2 3 4 5 6

No need to swap




577123542 101

1 2 3 4 5 6

Swap5 101




77123542 5

1 2 3 4 5 6

101

Largest value correctly placed

An Animated Example

674523 14 6 3398 42

1 2 3 4 5 6 7 8

to_do

index

7

N 8 did_swap true

An Animated Example

674523 14 6 3398 42

1 2 3 4 5 6 7 8

to_do

index

7

1

N 8 did_swap false

An Animated Example

674523 14 6 3398 42

1 2 3 4 5 6 7 8

to_do

index

7

1

N 8

Swap

did_swap false

An Animated Example

674598 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

1

N 8

Swap

did_swap true

An Animated Example

674598 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

2

N 8 did_swap true

An Animated Example

674598 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

2

N 8

Swap

did_swap true

An Animated Example

679845 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

2

N 8

Swap

did_swap true

An Animated Example

679845 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

3

N 8 did_swap true

An Animated Example

679845 14 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

3

N 8

Swap

did_swap true

An Animated Example

671445 98 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

3

N 8

Swap

did_swap true

An Animated Example

671445 98 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

4

N 8 did_swap true

An Animated Example

671445 98 6 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

4

N 8

Swap

did_swap true

An Animated Example

671445 6 98 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

4

N 8

Swap

did_swap true

An Animated Example

671445 6 98 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

5

N 8 did_swap true

An Animated Example

671445 6 98 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

5

N 8

Swap

did_swap true

An Animated Example

981445 6 67 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

5

N 8

Swap

did_swap true

An Animated Example

981445 6 67 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

6

N 8 did_swap true

An Animated Example

981445 6 67 3323 42

1 2 3 4 5 6 7 8

to_do

index

7

6

N 8

Swap

did_swap true

An Animated Example

331445 6 67 9823 42

1 2 3 4 5 6 7 8

to_do

index

7

6

N 8

Swap

did_swap true

An Animated Example

331445 6 67 9823 42

1 2 3 4 5 6 7 8

to_do

index

7

7

N 8 did_swap true

An Animated Example

331445 6 67 9823 42

1 2 3 4 5 6 7 8

to_do

index

7

7

N 8

Swap

did_swap true

An Animated Example

331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

7

7

N 8

Swap

did_swap true

After First Pass of Outer Loop

331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

7

8

N 8

Finished first “Bubble Up”

did_swap true

The Second “Bubble Up”

331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

1

N 8 did_swap false


331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

1

N 8 did_swap false

No Swap


331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

2

N 8 did_swap false


331445 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

2

N 8 did_swap false

Swap


334514 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

2

N 8 did_swap true

Swap


334514 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

3

N 8 did_swap true


334514 6 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

3

N 8 did_swap true

Swap


33614 45 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

3

N 8 did_swap true

Swap


33614 45 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

4

N 8 did_swap true


33614 45 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

4

N 8 did_swap true

No Swap


33614 45 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

5

N 8 did_swap true


33614 45 67 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

5

N 8 did_swap true

Swap


67614 45 33 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

5

N 8 did_swap true

Swap


67614 45 33 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

6

N 8 did_swap true


67614 45 33 4223 98

1 2 3 4 5 6 7 8

to_do

index

6

6

N 8 did_swap true

Swap


42614 45 33 6723 98

1 2 3 4 5 6 7 8

to_do

index

6

6

N 8 did_swap true

Swap

After Second Pass of Outer Loop

42614 45 33 6723 98

1 2 3 4 5 6 7 8

to_do

index

6

7

N 8 did_swap true

Finished second “Bubble Up”

The Third “Bubble Up”

42614 45 33 6723 98

1 2 3 4 5 6 7 8

to_do

index

5

1

N 8 did_swap false


42614 45 33 6723 98

1 2 3 4 5 6 7 8

to_do

index

5

1

N 8 did_swap false

Swap


42623 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

1

N 8 did_swap true

Swap


42623 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

2

N 8 did_swap true


42623 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

2

N 8 did_swap true

Swap


42236 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

2

N 8 did_swap true

Swap


42236 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

3

N 8 did_swap true


42236 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

3

N 8 did_swap true

No Swap


42236 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

4

N 8 did_swap true


42236 45 33 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

4

N 8 did_swap true

Swap


42236 33 45 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

4

N 8 did_swap true

Swap


42236 33 45 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

5

N 8 did_swap true


42236 33 45 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

5

N 8 did_swap true

Swap


45236 33 42 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

5

N 8 did_swap true

Swap

After Third Pass of Outer Loop

45236 33 42 6714 98

1 2 3 4 5 6 7 8

to_do

index

5

6

N 8 did_swap true

Finished third “Bubble Up”

The Fourth “Bubble Up”

45236 33 42 6714 98

1 2 3 4 5 6 7 8

to_do

index

4

1

N 8 did_swap false


45236 33 42 6714 98

1 2 3 4 5 6 7 8

to_do

index

4

1

N 8 did_swap false

Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

1

N 8 did_swap true

Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

2

N 8 did_swap true


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

2

N 8 did_swap true

No Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

3

N 8 did_swap true


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

3

N 8 did_swap true

No Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

4

N 8 did_swap true


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

4

N 8 did_swap true

No Swap

After Fourth Pass of Outer Loop

452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

4

5

N 8 did_swap true

Finished fourth “Bubble Up”

The Fifth “Bubble Up”

452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

1

N 8 did_swap false


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

1

N 8 did_swap false

No Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

2

N 8 did_swap false


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

2

N 8 did_swap false

No Swap


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

3

N 8 did_swap false


452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

3

N 8 did_swap false

No Swap

After Fifth Pass of Outer Loop

452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

4

N 8 did_swap false

Finished fifth “Bubble Up”

Finished “Early”

452314 33 42 676 98

1 2 3 4 5 6 7 8

to_do

index

3

4

N 8 did_swap false

We didn’t do any swapping,so all of the other elementsmust be correctly placed.

We can “skip” the last twopasses of the outer loop.

Example: #include <stdio.h> void bubble_sort(long [], long); int main() { long array[100], n, c, d, swap; printf("Enter number of elements:"); scanf("%ld", &n); printf("Enter %ld longegers\n", n); for (c = 0; c < n; c++) scanf("%ld", &array[c]); bubble_sort(array, n); printf("Sorted list in ascending order:n"); for ( c = 0 ; c < n ; c++ ) printf("%ld\n", array[c]); return 0; }

void bubble_sort(long list[], long n) { long c, d, t; for (c = 0 ; c < ( n - 1 ); c++) {

for (d = 0 ; d < n - c - 1; d++) { if (list[d] > list[d+1]) { t = list[d]; list[d] = list[d+1]; list[d+1]= t; } } } }

bubsort1 .c

Selection Sort……

Selection Sort…… Idea:

Find the largest element in the array Exchange it with the element in the

rightmost position Find the second largest element and

exchange it with the element in the second rightmost position

Continue until the array is sorted

Before sorting 14 2 10 5 1 3 17 7

After pass 1 14 2 10 5 1 3 7 17

After pass 2 7 2 10 5 1 3 14 17

After pass 3 7 2 3 5 1 10 14 17

After pass 4 1 2 3 5 7 10 14 17

Selection Sort

5 1 3 4 6 2

Comparison

Data Movement

Sorted

Selection Sort

5 1 3 4 6 2

Comparison

Data Movement

Sorted

Largest

Selection Sort

5 1 3 4 2 6

Comparison

Data Movement

Sorted

Selection Sort

5 1 3 4 2 6

Comparison

Data Movement

Sorted

Largest

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Largest

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Largest

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Selection Sort

2 1 3 4 5 6

Comparison

Data Movement

Sorted

Largest

Selection Sort

1 2 3 4 5 6

Comparison

Data Movement

Sorted

Selection Sort

1 2 3 4 5 6

Comparison

Data Movement

Sorted

DONE!

Example:

#include <stdio.h> main() { int A[20], N, Temp, i, j; printf(" ENTER THE NUMBER OF TERMS...: "); scanf("%d",&N); printf("\n ENTER THE ELEMENTS OF THE ARRAY...:"); for(i=1; i<=N; i++) { scanf("\n\t\t%d", &A[i]); }

for(i=1; i<=N-1; i++) for(j=i+1; j<=N;j++) if(A[i]>A[j]) { Temp = A[i]; A[i] = A[j]; A[j] = Temp; } printf("THE ASCENDING ORDER LIST IS...:\n"); for(i=1; i<=N; i++) printf("\n %d",A[i]); }

selecsort .c

Insertion Sort……

134 Insertion Sort…… Idea: like sorting a hand of playing cards

Start with an empty left hand and the cards facing down on the table.

Remove one card at a time from the table, and insert it into the correct position in the left hand

compare it with each of the cards already in the hand, from right to left

The cards held in the left hand are sorted

these cards were originally the top cards of the pile on the table

135

To insert 12, we need to make room for it by moving first 36 and then 24.

Insertion Sort

6 10 24

12

36

136

6 10 24

Insertion Sort

36

12

137

Insertion Sort

6 10 24 36

12

138 Insertion Sort

5 2 4 6 1 3

input array

left sub-array right sub-array

at each iteration, the array is divided in two sub-arrays:

sorted unsorted

139 Insertion Sort

#include<stdio.h> void main() { int A[20], N, Temp, i, j; printf("ENTER THE NUMBER OF TERMS...: "); scanf("%d", &N); printf("\n ENTER THE ELEMENTS OF THE ARRAY...:"); for(i=0; i<N; i++) { scanf("\n\t\t%d",&A[i]); }

Example:

for(i=1; i<N; i++) { Temp = A[i]; j = i-1; while(Temp<A[j] && j>=0) { A[j+1] = A[j]; j = j-1; } A[j+1] = Temp; } printf("\nTHE ASCENDING ORDER LIST IS...:\n"); for(i=0; i<N; i++) printf("\n%d", A[i]); }

inrsot .c

THANK YOU FOR

LISTENING

THEEND

Sorting techniques Anil Dutt

Engineering

Transcript of Sorting techniques Anil Dutt