Ceng-112 Data Structures I2006 1 Chapter 11 Sorting

Ceng-112 Data Structures I 2006 1

Chapter 11

Sorting


Figure 11-1


Figure 11-2

Buble sort and straight insertion sort are stable, all of the others are unstable.


• It uses two pieces of data to sort: sorted and unsorted.

• In each pass of a sort, one or more pieces of data are

inserted into their correct location.

1. The straight insertion sort

2. The shell sort

Insertion Sort


Figure 11-3

Insertion SortStraight Insertion Sort

•It will take at most n-1 passes to sort the data.

• It uses two pieces of data to sort: sorted and unsorted.

• In each pass, the first element of the the unsorted sublist is

transfered to the sorted sublist by insertion it at appropiate

place.


Figure 11-4



algorithm insertionSort( ref list <array>, val last <index>)

Sort list[1..last] using insertion sort. The array is divided into

sorted and unsorted lists. With each pass, the first element of

unsorted list is inserted into sorted list.

Pre List must contain at least one element.

last is an index to last element in the list.

Post List has been rearranged.



1. current = 2

2. loop (current <= last)

1. hold = list[current]

2. walker = current -1

3. loop (walker >=1 AND hold.key < list[walker].key)

• list[walker+1] = list[walker]

• walker = walker -1

4. list[walker +1] = hold

5. current = current +1

3. return

end insertionSort


Inside loop is quadraticly dependent to outer loopand outer loop executes n-1 times.

f(n)=n((n+1)/2)O(n2)


• The creator of this algorithm is Donald L.Shell.

• The list is divided into K segments, where K is known as the

increment value.

• Each segment contains N/K or less elemets.

• After each pass through, the data in each segment are ordered.

• If there is only one segment, then the list is sorted.

Insertion SortShell Sort


Figure 11-5


K = 3, three segments and K is an increment value.Each segment includes N/K or less elements. If there is only one segment, then the list is sorted.

77 62 14 9 30 21 80 25 70 55

77

62

14

9

30

21

80

25

70

55


Figure 11-6, a


k=last/2k = 10/2=5


Figure 11-6, b


k=5/2


Figure 11-6, c and d

Insertion SortShell Sort k=3/2


A[1] A[1 + K] A[1 + 2K] A[1 + 3K]

Sorted Unsorted



algorithm shellSort( ref list <array>, val last <index>)

Sort list[1], list[2],..,list[last] are sorted in place. After the sort,

their keys will be in order,

list[1].key <= list[2].key <=..<=list[last].key.

Pre List is an unordered array of records.

last is an index to last record in array.

Post List is ordered on list[i].key.



1. incre = last /22. loop (incre not 0)

1. current = 1 + incre2. loop (current <= last)

1. hold = list[current]2. walker = current – incre3. loop (walker >= 1 AND hold.key < list[walker].key)

• list[walker+incre] = list[walker]• walker = walker – incre

4. list[walker + incre] = hold5. current = current + 1

3. incre = incre /23. returnend shellSort


log2n[(n-n/2)+(n-n/4)+..+1]=n.log2nO(n.log2n)

We still need to include the third loop!

O(n1.25)

executes log2n

n - increment times

each time n = n/2


Selection Sort

• We simply select the smallest item in the list and place it in

a sorted list.

• These steps are repeated until all of data have been sorted.

1. Straight Selection Sort

2. Heap Sort


Figure 11-8

Selection SortStraight Selection Sort

• The list is divided into two sublists, sorted and unsorted.

• Select the smallest element from unsorted sublist and exchange it with the element at the beginning of the unsorted data.

• The wall between two sublists moves one element.


Figure 11-9



algorithm selectionSort( ref list <array>, val last <index>)

Sort list[1..last] by selecting smallest element in unsorted portion

of array and exchanging it with element at the beginning of the

unordered list.

Pre List is must contain at least one item.


Post List has been rearranged smallest to largest.



1. current = 12. loop (current < last)

1. smallest = current2. walker = current +13. loop (walker <= last)

1. if ( list[walker] < list[smallest])• smallest = walker

2. walker = walker + 1• smallest selected: exchange with current element!

exchange (list, current, smallest)• current = current + 1

3. returnend selectionSort


O(n2)

executes n – 1 times

executes n – 1 times


Figure 11-10

Selection SortHeap Sort


Figure 11-11

Selection SortHeap Sort


Exchange Sort

Exchange sorting, contains:

1. The most common sort in computer science; the buble sort.

2. The most efficient general purpose sort; the quick sort.


Figure 11-12

Exchange Sort Bubble Sort

• The list is divided into two sublists; sorted and unsorted.• The smallest element is bubbled from the unsorted to the sorted list.• The wall moves one element to the right.• This sort requires n-1 passes to sort the data.


Figure 11-13


currentwalker


algorithm bubleSort( ref list <array>, val last <index>)

Sort an array, list[1..last] using buble sort.Adjacent elements are

compared and exchanged until list is completely ordered.

Pre List is must contain at least one item.


Post List has been rearranged smallest to largest.



• current = 1• sorted = false• loop (current <= last AND sorted false)

1. walker = last2. sorted = true3. loop (walker > current)

1. if (list[walker] < list[walker-1])• sorted = false• exchange (list, walker, walker-1)

2. walker = walker – 1

4. current = current + 11. returnend bubleSort


f(n) = n((n+1)/2)O(n2)

executes n times

executes (n+1)/2 times


Exchange Sort

• In the buble sort, consecutive items are compared and possibly

exchanged on each pass through the list, which means that

many exchanges may be needed to move an element to its

correct position.

• Quick sort is exchanged involves elements that are far apart so

that fewer exchanges are required to correctly position an

element.


Hw - 12

• Create an array has 40 elements which are selected randomly between 0 and 1000.

• Print the unsorted array.

• Use the shell sort to sort the array.

• Print the sorted array elements again.

Load your HW-12 to FTP site until 01 June 07 at 09:00.


Exchange Sort Quick Sort

• Selects an element which is called as “pivot” for each iteration.

• Divides the list into three groups.

1. The elements of first group which has key values less then key of pivot.

2. The pivot element.

3. The elements of first group which has key values greater then key of pivot.

• The sorting continues by quick sorting the left partition followed by a quick sort of the right partition.


Figure 11-14


>

>


Figure 11-15>=


78 >62

84 >62

45 < 62

From right!21 < 62

14 < 62

97 > 62

From left!


Figure 11-16

Exchange Sort Quick Sort Operation


algorithm quickSort( ref list <array>, val left <index>,

val right <index>)

An array, list[left..right] is sorted using recursion.

Pre List is an array of data to be sorted.

left and right identify the first and last elements of the list

respectively.

Post the list is sorted.



1. if ((right – left) > minsize) // quick sort• medianLeft( list, left, right)• pivot = list(left)• sortLeft = left +1• sortRight = right• loop (sortLeft <= sortRight)

• (find keys on left that belongs on right)• loop ((list[sortLeft].key < pivot.key)AND(sortLeft < sortRight))

• sortLeft = sortLeft + 11. loop ((list[sortRight].key >=

pivot.key)AND(sortRight<sortLeft))• sortRight = sortRight – 1

2. if (sortLeft < sortRight)1. Exchange(list, sortLeft, sortRight)2. sortLeft = sortLeft + 13. sortRight = sortRight – 1

• (prepare for next phase)1. list[left] = list[sortLeft – 1]• list[sortLeft – 1] = pivot• if (left < sortRight)

• quickSort(list, left, sortRight-1)– if (sortLeft < right)

• quickSort(list, sortLeft, right)• else insertionSort(list, left, right)end quickSort

O(n.log2 n)


Quick Sort medianLeft Algorithm

algorithm medianLeft(ref sortData <array>, val left <index>, val right <index>)

Find the median value of an array, sortData[left, right], and place it in the location sortData[left].

Pre sortData is an array of at least three elements left and right are the boundaries of the array.Post median value located and placed at sortData[left].Rearrange sortData so median value is in the middle location.1. mid = (left + right) / 22. if (sortData[left].key > sortData[mid].key)

• exchange(sortData, left, mid)3. if (sortData[left].key > sortData[right].key)

• exchange(sortData, left, right)4. if (sortData[mid].key > sortData[right].key)

• exchange(sortData, mid, right)• (Median in inthe middle location, exchange it with left).• exchange(sortData, left, mid)• Returnend medianLeft


algorithm quickInsertion( ref list <array>, val first <index>, val last <index>)

Sort list[1..last] using insertion sort. The array is divided into sorted and unsorted

lists. With each pass, the first element of unsorted list is inserted into sorted list.

Pre List must contain at least one element.

first is an index to the first element in the list.

last is an index to last element in the list

Post List has been rearranged.

Quick Sort quickInsertion Algorithm


1. current = first +1

2. loop (current <= last)

1. hold = list[current]

2. walker = current -1

3. loop (walker >=first AND hold.key < list[walker].key)

• list[walker+1] = list[walker]

• walker = walker -1

4. list[walker +1] = hold

5. current = current +1

3. return

end quickInsertion

Quick Sort quickInsertion Algorithm


Quick Sort Example


Merge Sort


Merge Sort




Merge Sort


Merge Sort




Merging Pseudocode







Counting Sort The counting sort is a linear algorithm to sort a list. The

pseudocode algorith is:Arrays: A[1,..,n] original unsorted array

B[1,..,n] array to hold sorted outputC[1,..,k] working array to hold counts

Counting_Sort(A, B, k)1. // initialize the count array2. for i=1 to k3. C[i]=04. for j=1 to length[A]5. C[ A[j] ]=C[ A[j] ] + 16. // C[i] now contains the number of elements equal to k.7. for i=2 to k8. C[i] = C[i] + C[i-1]9. // C[i] now contains the number of elements less than or

equal to i.10. for j= length[A] downto 111. B[ C[ A[j] ] ] = A[j]• C[ A[j] ] = C[ A[j] ] – 1• // Array B holds now the sorted sequence.


Sample for Counting Sort

for i=1 to k C[i]=0

for j=1 to length[A] C[ A[j] ]=C[ A[j] ] + 1



for j= length[A] downto 1 B[ C[ A[j] ] ] = A[j] C[ A[j] ] = C[ A[j] ] – 1

for i=2 to k C[i] = C[i] + C[i-1]



for j= length[A] downto 1 B[ C[ A[j] ] ] = A[j] C[ A[j] ] = C[ A[j] ] – 1




• Lineer time sorting algorithm and no comparisons needed.

• Assume n elements in range 1 to k. When k = O(n), running

time is O(n).

Counting Sort

Documents

Ceng-112 Data Structures I2006 1 Chapter 11 Sorting