Post on 05-Jan-2016
description
Sorting
• A fundamental operation in computer science (many programs need to sort as an intermediate step).
• Many sorting algorithms have been developed• Choose a criteria which is used to order data
– Given a list of records that have keys, use those keys to define an ordering of the items in the list
• To sort a set of data, the data have to be compared and moved as necessary. Thus, measure the efficiency of a sorting algorithm by:– Number of data comparisons it needs to perform– Number of data movements it needs to perform
Elementary Sorting Algorithms
• given n items to sort• There are a number of simple sorting
algorithms whose worst and average case time complexity is quadratic (i.e., O(n2))– Insertion sort– Selection sort– Bubble sort
Insertion Sort
• Given an array of data items:– The insertion sort algorithm views the array as having
a sorted side and an unsorted side– The sorted side starts with the first element, which is
not necessarily the smallest element– The sorted side grows by taking the front element
from the unsorted side and inserting it in the place that keeps the sorted side arranged from small to large
– In some cases there is no need to move the new inserted item
The Insertion Sort Algorithmtemplate <class T>void insertionsort(T data[], int n){
for(int i=1, j; i<n; i++){T tmp =data[i]; //take next key from unsorted part of array
for (j =i; j>0 && tmp < data[j-1]; j--) //shift data down to make room for inserting tmp if necessary
data[j] = data[j-1];
data[j] = tmp; //insert in appropriate location in sorted part of array
}
}
Complexity of Insertion Sort
• Best case O(n)• Worst and average case O(n2)
Selection Sort
• Basic idea:– Repeatedly select the smallest element and move
this element to the front of the unsorted side
selectionsorttemplate<class T>void selectionsort(T data[], int n) { int j; for (int i = 0, least, j; i < n-1; i++) {
//find the index of the smallest element in the unsorted part of array for (j = i+1, least = i; j < n; j++)
if (data[j] < data[least]) least = j;
//put the ith smallest to the i-1th position swap(data[least],data[i]); }}
Selection Sort (cont’d)
• Given an array of integers:– Start by finding the smallest element• Swap the smallest entry with the first element• Part of the array is sorted
– Find the smallest element in the unsorted side• Swap with the front of the unsorted side• The size of the sorted side is increased by one element
– Continue until the unsorted side has just one number.
selectionsort
• complexity
BubbleSort• Given an array of integers:– Scan the array from right to left– Look at pairs of elements (adjacent elements) in the
array and swap their order if needed (i.e., if the left element is larger than the right element)
– Repeatedly scan the array from right to left looking at pairs of elements and swapping their order if needed• In this way, the smallest element is “bubbled” all the way to
the first position of the array– Scan the array again from right to left to “bubble” the
second smallest element to the second of the array– Continue scanning until done
bubblesort
template<class T>void bubblesort(T data[], int n) { // n passes, each pass ”bubble” one element for (int i = 0; i < n-1; i++) //keep comparing adjacent elements
for (int j = n-1; j > i; --j) if (data[j] < data[j-1]) swap(data[j],data[j-1]);}
BubbleSort
• complexity
Elementary Sorting Algorithms
• Selection Sort, Insertion Sort, and Bubble Sort all have a worst-case time of O(n2), making them impractical for large arrays
• But they are easy to program, easy to debug• Insertion Sort also has good performance when the
array is nearly sorted to begin with• But more sophisticated algorithms are needed when
good performance is needed in all cases for large arrays– Heap Sort– Quick Sort– Merge Sort