Sorting Sorting Arranging items in a collection so that there is an ordering on one (or more) of the...

transcript

Sorting

SortingArranging items in a collection so that there is an ordering on one (or more) of the fields in the itemsSort KeyThe field (or fields) on which the ordering is basedSorting algorithmsAlgorithms that order the items in the collection based on the sort key

Why is sorting important?

Chapter 13 presents several common algorithms for sorting an array of integers.

Two slow but simple algorithms are Selectionsort and Insertionsort.

This presentation demonstrates how the two algorithms work.

Quadratic Sorting

Data Structuresand Other ObjectsUsing C++

Selection Sort

Given a list of names, put them in alphabetical order Find the name that comes first in the alphabet,

and write it on a second sheet of paper

Cross out the name off the original list

Continue this cycle until all the names on the original list have been crossed out and written onto the second list, at which point the second list contains the same items but in sorted order

Selection Sort

A slight adjustment to this manual approach does away with the need to duplicate space

As you cross a name off the original list, a free space opens up

Instead of writing the value found on a second list, exchange it with the value currently in the position where the crossed-off item should go

Selection Sort

Figure 9.9 Example of a selection sort (sorted elements are shaded)

Sorting an Array of Integers

The picture shows an array of six integers that we want to sort from smallest to largest [1] [2] [3] [4] [5] [6]

[1] [2] [3] [4] [5] [6][0] [1] [2] [3] [4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

The Selectionsort Algorithm

Start by finding the smallest entry.

[0] [1] [2] [3] [4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Swap the smallest entry with the first entry. [0] [1] [2] [3]

[4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Swap the smallest entry with the first entry. [0] [1] [2] [3]

[4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Part of the array is now sorted.

Sorted side Unsorted side

[0] [1] [2] [3] [4] [5]

Find the smallest element in the unsorted side.

[0] [1] [2] [3] [4] [5]

Find the smallest element in the unsorted side.

Swap with the front of the unsorted side.

[0] [1] [2] [3] [4] [5]

We have increased the size of the sorted side by one element.

[0] [1] [2] [3] [4] [5]

The process continues...

Smallestfrom

unsorted

[0] [1] [2] [3] [4] [5]

Sorted side Unsorted sideSorted side

is bigger

[0] [1] [2] [3] [4] [5]

The process keeps adding one more number to the sorted side.

The sorted side has the smallest numbers, arranged from small to large.

[0] [1] [2] [3] [4] [5]

We can stop when the unsorted side has just one number, since that number must be the largest number.

[0] [1] [2] [3] [4] [5]

The array is now sorted.

We repeatedly selected the smallest element, and moved this element to the front of the unsorted side.

[0] [1] [2] [3] [4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

The Insertionsort Algorithm

The Insertionsort algorithm also views the array as having a sorted side and an unsorted side.

[0] [1] [2] [3] [4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

The sorted side starts with just the first element, which is not necessarily the smallest element.

[0] [1] [2] [3] [4] [5]

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

The sorted side grows by taking the front element from the unsorted side...

for (int i = 1; i < v.size(); i++) { int cur = v[i]; // slide cur down into position to left

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

...and inserting it in the place that keeps the sorted side arranged from small to large.

j=i-1 i=1

for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];cur

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

In this example, the new element goes in front of the element that was already in the sorted side.

for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];v[j+1] = cur;

j--j+1=0

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Sometimes we are lucky and the new inserted item doesn't need to move at all.

for (int i = 1; i < v.size(); i++) { int cur = v[i]; // slide cur down into position to left

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Sometimes we are lucky twice in a row.

v[j+1] = cur;

for (int j=i-1; j >= 0 && v[j] > cur; j--) v[j+1] = v[j];

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

How to Insert One Element

Copy the new element to a separate location.

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Shift elements in the sorted side, creating an open space for the new element.

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Shift elements in the sorted side, creating an open space for the new element.

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Continue shifting elements...

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Continue shifting elements...

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

...until you reach the location for the new element.

[1] [2] [3] [4] [5] [6]0

[1] [2] [3] [4] [5] [6]

Copy the new element back into the array, at the correct location.

v[j+1] = cur;

The last element must also be inserted. Start by copying it...

[0] [1] [2] [3] [4] [5]

Bubble Sort

Bubble Sort uses the same strategy:Find the next itemPut it into its proper place

But uses a different scheme for finding the next item Starting with the last list element, compare

successive pairs of elements, swapping whenever the bottom element of the pair is smaller than the one above it

Bubble Sort

Figure 9.10 Example of a bubble sort

Algorithms

Can you write the algorithms for the selection sort and the bubble sort?

Can you think of a way to make the bubble sort more efficient?

Logarithmic Sorting

* Quick Sort* Merge Sort

Quicksort

Figure 9.12 Ordering a list using the Quicksort algorithm

It is easier to sort a smallernumber of items: Sort A…F, G…L, M…R, and S…Z andA…Z is sorted

Quicksort

QuicksortIf (there is more than one item in list[first]..list[last])

Select splitValSplit the list so that

list[first]..list[splitPoint-1] <= splitVallist[splitPoint] = splitVallist[splitPoint+1]..list[last] > splitVal

Quicksort the left halfQuicksort the right half

Quicksort

Split Set left to first + 1Set right to lastDo

Increment left until list[left] > splitVal OR left > rightDecrement right until list[right] < splitVal OR left > right If (left < right)

Swap list[left] and list[right]While (left <= right)Set splitPoint to rightSwap list[first] and last[right]

Quicksort

Figure 9.13 Splitting algorithm

Quick Sort Code

void Quicksort(Vector<int> &v, int start, int stop) {

if (stop > start) { //base case int pivot = Partition(v, start, stop); //partition Quicksort(v, start, pivot-1); //recursive sort left Quicksort(v, pivot+1, stop);//recursive sort right } }

Partition Code – set up pivot

int Partition(vector<int> & arr, int start, int stop) { int lh = start + 1; //left hand int rh = stop; //right hand int pivot; //variable to hold pivot pivot = arr[start]; //set pivot to first element

Partition Code—Move to center

while(true) { while(lh < rh && arr[rh] >= pivot) rh--; while(lh <rh && arr[lh] < pivot) lh++; if(lh == rh) break; //base case

Partition Code—Swap

while(true) { while(lh < rh && arr[rh] >= pivot) rh--; while(lh <rh && arr[lh] < pivot) lh++; if(lh == rh) break; //base case swap(arr[lh], arr[rh]); }

Partition Code—Left Overs?

if(arr[lh] >= pivot) return start; swap(arr[start], arr[lh]; return lh;

} //end Partition function

Merge Sort—Partition

8 7 4 3 9 5 10

8 7 4 3

9 5 10

9 5 4 3 10

Merge Sort—Merge

9 4 107

Compare -- smallest goes first

Merge Sort—Merge

9 4 10

Merge Sort—Merge

9 4 10

Merge Sort—Merge

9 4 10

Merge Sort—Merge

9 4 107

Merge Sort—Merge

9 4 107

Merge Sort—Merge

9 4 107

Compare –smallest goes firstCompare—smallest goes first

Choose smallest from each stack

Merge Sort—Merge

9 4 107

Compare –smallest goes firstCompare—smallest goes first

Choose smallest from each stack

Merge Sort—Merge

Compare –smallest firstCompare --smallest first

Merge Sort—Merge

9 4 107

Compare –smallest firstCompare –smallest first

Merge Sort—Merge

9 4 107

Compare –smallest goes first

Merge Sort—Merge

9 4 107

Compare –smallest first

Merge Sort—Merge

9 4 107

Merge Sort—Merge

Compare—smallest first

Merge Sort—Merge

The remainders

Merge Sort—Merge

The remainders

Merge Sort—Done

9 4 107

A Quiz

How many shifts will occur before we copy this element back into the array?

[0] [1] [2] [3] [4] [5]

A Quiz

Four items are shifted.

[0] [1] [2] [3] [4] [5]

A Quiz

Four items are shifted.And then the element is copied back into the array.

[0] [1] [2] [3] [4] [5]

Both Selectionsort and Insertionsort have a worst-case time of O(n2), making them impractical for large arrays.

But they are easy to program, easy to debug. Insertionsort also has good performance when the

array is nearly sorted to begin with. But more sophisticated sorting algorithms are

needed when good performance is needed in all cases for large arrays.

Timing and Other Issues

THE END

Some artwork in the presentation is used with permission from Presentation Task Force(copyright New Vision Technologies Inc) and Corel Gallery Clipart Catalog (copyrightCorel Corporation, 3G Graphics Inc, Archive Arts, Cartesia Software, Image ClubGraphics Inc, One Mile Up Inc, TechPool Studios, Totem Graphics Inc).

Students and instructors who use Data Structures and Other Objects Using C++ are welcometo use this presentation however they see fit, so long as this copyright notice remainsintact.

Sorting Sorting Arranging items in a collection so that there is an ordering on one (or more) of the...

Documents