chapter 10 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Chapter 10 PowerPoint Presentation
Download Presentation
Chapter 10

Loading in 2 Seconds...

play fullscreen
1 / 61

Chapter 10 - PowerPoint PPT Presentation


  • 120 Views
  • Uploaded on

Chapter 10. Sorting Algorithms. Chapter Objectives. Learn the various sorting algorithms Explore how to implement the selection, insertion, quick, merge, and heap sorting algorithms Discover how the sorting algorithms discussed in this chapter perform

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Chapter 10' - peta


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapter 10

Chapter 10

Sorting Algorithms

Data Structures Using C++

chapter objectives
Chapter Objectives
  • Learn the various sorting algorithms
  • Explore how to implement the selection, insertion, quick, merge, and heap sorting algorithms
  • Discover how the sorting algorithms discussed in this chapter perform
  • Learn how priority queues are implemented

Data Structures Using C++

selection sort
Selection Sort
  • Sorts list by
    • Finding smallest (or equivalently largest) element in the list
    • Moving it to the beginning (or end) of the list by swapping it with element in beginning (or end) position

Data Structures Using C++

class orderedarraylisttype
class orderedArrayListType

template<class elemType>

class orderedArrayListType: public arrayListType

{

public:

void selectionSort();

...

};

Data Structures Using C++

smallest element in list function
Smallest Element in List Function

template<class elemType>

int orderedArrayListType<elemType>::minLocation(int first, int last)

{

int loc, minIndex;

minIndex = first;

for(loc = first + 1; loc <= last; loc++)

if(list[loc] < list[minIndex])

minIndex = loc;

return minIndex;

}//end minLocation

Data Structures Using C++

swap function
Swap Function

template<class elemType>

void orderedArrayListType<elemType>::swap(int first, int second)

{

elemType temp;

temp = list[first];

list[first] = list[second];

list[second] = temp;

}//end swap

Data Structures Using C++

selection sort function
Selection Sort Function

template<class elemType>

void orderedArrayListType<elemType>::selectionSort()

{

int loc, minIndex;

for(loc = 0; loc < length - 1; loc++)

{

minIndex = minLocation(loc, length - 1);

swap(loc, minIndex);

}

}

Data Structures Using C++

analysis selection sort
Analysis: Selection Sort

By analyzing the number of key comparisons, we see that selection sort is an O(n2) algorithm:

Data Structures Using C++

class orderedarraylisttype1
class orderedArrayListType

template<class elemType>

class orderedArrayListType: public arrayListType<elemType>

{

public:

void insertOrd(const elemType&);

int binarySearch(const elemType& item);

void selectionSort();

orderedArrayListType(int size = 100);

private:

void swap(int first, int second);

int minLocation(int first, int last);

};

Data Structures Using C++

insertion sort
Insertion Sort
  • Reduces number of key comparisons made in selection sort
  • Can be applied to both arrays and linked lists (examples follow)
  • Sorts list by
    • Finding first unsorted element in list
    • Moving it to its proper position

Data Structures Using C++

insertion sort array based lists
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists1
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists2
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists3
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists4
Insertion Sort: Array-Based Lists

for(firstOutOfOrder = 1; firstOutOfOrder < length; firstOutOfOrder++)

if(list[firstOutOfOrder] is less than list[firstOutOfOrder - 1])

{

copy list[firstOutOfOrder] into temp

initialize location to firstOutOfOrder

do

{

a. move list[location - 1] one array slot down

b. decrement location by 1 to consider the next element

of the sorted portion of the array

}

while(location > 0 && the element in the upper sublist at

location - 1 is greater than temp)

}

copy temp into list[location]

Data Structures Using C++

insertion sort array based lists5
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists6
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists7
Insertion Sort: Array-Based Lists

Data Structures Using C++

insertion sort array based lists8
Insertion Sort: Array-Based Lists

template<class elemType>

void orderedArrayListType<elemType>::insertionSort()

{

int firstOutOfOrder, location;

elemType temp;

for(firstOutOfOrder = 1; firstOutOfOrder < length;

firstOutOfOrder++)

if(list[firstOutOfOrder] < list[firstOutOfOrder - 1])

{

temp = list[firstOutOfOrder];

location = firstOutOfOrder;

do

{

list[location] = list[location - 1];

location--;

}while(location > 0 && list[location - 1] > temp);

list[location] = temp;

}

}//end insertionSort

Data Structures Using C++

insertion sort linked list based list1
Insertion Sort: Linked List-Based List

if(firstOutOfOrder->info is less than first->info)

move firstOutOfOrder before first

else

{

set trailCurrent to first

set current to the second node in the list

//search the list

while(current->info is less than firstOutOfOrder->info)

{

advance trailCurrent;

advance current;

}

if(current is not equal to firstOutOfOrder)

{ //insert firstOutOfOrder between current and trailCurrent

lastInOrder->link = firstOutOfOrder->link;

firstOutOfOrder->link = current;

trailCurrent->link = firstOutOfOrder;

}

else //firstOutOfOrder is already at the first place

lastInOrder = lastInOrder->link;

}

Data Structures Using C++

analysis insertion sort
Analysis: Insertion Sort

Data Structures Using C++

lower bound on comparison based sort algorithms
Lower Bound on Comparison-Based Sort Algorithms
  • Trace execution of comparison-based algorithm by using graph called comparison tree
  • Let L be a list of n distinct elements, where n > 0. For any j and k, where 1 = j, k = n, either L[j] < L[k] or L[j] > L[k]
  • Each comparison of the keys has two outcomes; comparison tree is a binary tree
  • Each comparison is a circle, called a node
  • Node is labeled as j:k, representing comparison of L[j] with L[k]
  • If L[j] < L[k], follow the left branch; otherwise, follow the right branch

Data Structures Using C++

lower bound on comparison based sort algorithms2
Lower Bound on Comparison-Based Sort Algorithms
  • Top node in the figure is the root node
  • Straight line that connects the two nodes is called a branch
  • A sequence of branches from a node, x, to another node, y, is called a path from x to y
  • Rectangle, called a leaf, represents the final ordering of the nodes
  • Theorem: Let L be a list of n distinct elements. Any sorting algorithm that sorts L by comparison of the keys only, in its worst case, makes at least O(n*log2n) key comparisons

Data Structures Using C++

quick sort
Quick Sort
  • Recursive algorithm
  • Uses the divide-and-conquer technique to sort a list
  • List is partitioned into two sublists, and the two sublists are then sorted and combined into one list in such a way so that the combined list is sorted

Data Structures Using C++

quick sort array based lists
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists1
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists2
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists3
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists4
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists5
Quick Sort: Array-Based Lists

Data Structures Using C++

quick sort array based lists6
Quick Sort: Array-Based Lists

template<class elemType>

int orderedArrayListType<elemType>::partition(int first, int last)

{

elemType pivot;

int index, smallIndex;

swap(first, (first + last)/2);

pivot = list[first];

smallIndex = first;

for(index = first + 1; index <= last; index++)

if(list[index] < pivot)

{

smallIndex++;

swap(smallIndex, index);

}

swap(first, smallIndex);

return smallIndex;

}

Data Structures Using C++

quick sort array based lists7
Quick Sort: Array-Based Lists

template<class elemType>

void orderedArrayListType<elemType>::swap(int first,int second)

{

elemType temp;

temp = list[first];

list[first] = list[second];

list[second] = temp;

} //end swap

Data Structures Using C++

quick sort array based lists8
Quick Sort: Array-Based Lists

template<class elemType>

void orderedArrayListType<elemType>::recQuickSort(int first, int last)

{

int pivotLocation;

if(first <last)

{

pivotLocation = partition(first, last);

recQuickSort(first, pivotLocation - 1);

recQuickSort(pivotLocation + 1, last);

}

} //end recQuickSort

template<class elemType>

void orderedArrayListType<elemType>::quickSort()

{

recQuickSort(0, length - 1);

}//end quickSort

Data Structures Using C++

quick sort array based lists9
Quick Sort: Array-Based Lists

Data Structures Using C++

merge sort
Merge Sort
  • Uses the divide-and-conquer technique to sort a list
  • Merge sort algorithm also partitions the list into two sublists, sorts the sublists, and then combines the sorted sublists into one sorted list

Data Structures Using C++

merge sort algorithm
Merge Sort Algorithm

Data Structures Using C++

divide
Divide

Data Structures Using C++

divide1
Divide

Data Structures Using C++

merge
Merge

Data Structures Using C++

merge1
Merge

Data Structures Using C++

analysis of merge sort
Analysis of Merge Sort

Suppose that L is a list of n elements, where n > 0.

Let A(n) denote the number of key comparisons in

the average case, and W(n) denote the number of key

comparisons in the worst case to sort L. It can be

shown that:

A(n) = n*log2n – 1.26n = O(n*log2n)

W(n) = n*log2n – (n–1) = O(n*log2n)

Data Structures Using C++

heap sort
Heap Sort
  • Definition: A heap is a list in which each element contains a key, such that the key in the element at position k in the list is at least as large as the key in the element at position 2k + 1 (if it exists), and 2k + 2 (if it exists)

Data Structures Using C++

heap sort array based lists
Heap Sort: Array-Based Lists

Data Structures Using C++

heap sort array based lists1
Heap Sort: Array-Based Lists

Data Structures Using C++

heap sort array based lists2
Heap Sort: Array-Based Lists

Data Structures Using C++

heap sort array based lists3
Heap Sort: Array-Based Lists

Data Structures Using C++

heap sort array based lists4
Heap Sort: Array-Based Lists

Data Structures Using C++

heap sort array based lists5
Heap Sort: Array-Based Lists

Data Structures Using C++

priority queues insertion
Priority Queues: Insertion

Assuming the priority queue is implemented as a heap:

  • Insert the new element in the first available position in the list. (This ensures that the array holding the list is a complete binary tree.)
  • After inserting the new element in the heap, the list may no longer be a heap. So to restore the heap:

while (parent of new entry < new entry)

swap the parent with the new entry

Data Structures Using C++

priority queues remove
Priority Queues: Remove

Assuming the priority queue is implemented

as a heap, to remove the first element of the

priority queue:

  • Copy the last element of the list into the first array position.
  • Reduce the length of the list by 1.
  • Restore the heap in the list.

Data Structures Using C++

chapter summary
Chapter Summary
  • Sorting Algorithms
    • Selection sort
    • Insertion sort
    • Quick sort
    • Merge sort
    • heap sort
  • Algorithm analysis
  • Priority queues

Data Structures Using C++