Download chap09 - MCST-CS

Chapter 9
Sorting Algorithms
Data Structures Using Java
1
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 Java
2
Selection Sort
Selection Sort Methodology:
1. Find smallest (or equivalently largest)
element in the list
2. Move it to the beginning (or end) of the list
by swapping it with element in beginning (or
end) position
Data Structures Using Java
3
class OrderedArrayList
public class OrderedArrayList extends ArrayListClass
{
public void selectionSort();
{
//statements
}
...
};
Data Structures Using Java
4
Smallest Element in List
Function
private int 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 Java
5
Swap Function
private void swap(int first, int second)
{
DataElement temp;
temp = list[first];
list[first] = list[second];
list[second] = temp;
}//end swap
Data Structures Using Java
6
Selection Sort Function
public void selectionSort()
{
int loc, minIndex;
for(loc = 0; loc < length; loc++)
{
minIndex = minLocation(loc, length - 1);
swap(loc, minIndex);
}
}
Data Structures Using Java
7
Selection Sort Example:
Array-Based Lists
Data Structures Using Java
8
Selection Sort Example:
Array-Based Lists
Data Structures Using Java
9
Selection Sort Example:
Array-Based Lists
Data Structures Using Java
10
Selection Sort Example:
Array-Based Lists
Data Structures Using Java
11
Analysis: Selection Sort
Data Structures Using Java
12
Insertion Sort
• Reduces number of key comparisons made in
selection sort
• Can be applied to both arrays and linked lists
(examples follow)
• Methodology
– Find first unsorted element in list
– Move it to its proper position
Data Structures Using Java
13
Insertion Sort: Array-Based Lists
Data Structures Using Java
14
Insertion Sort: Array-Based Lists
Data Structures Using Java
15
Insertion Sort: Array-Based Lists
Data Structures Using Java
16
Insertion Sort: Array-Based Lists
Data Structures Using Java
17
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 Java
18
Insertion Sort: Array-Based Lists
Data Structures Using Java
19
Insertion Sort: Array-Based Lists
Data Structures Using Java
20
Insertion Sort: Array-Based Lists
Data Structures Using Java
21
Insertion Sort: Array-Based Lists
public void insertionSort()
{
int unsortedIndex, location;
DataElement temp;
for(unsortedIndex = 1; unsortedIndex < length; unsortedIndex++)
if(list[unsortedIndex].compareTo(list[unsortedIndex - 1]) < 0)
{
temp = list[unsortedIndex];
location = unsortedIndex;
do
{
list[location] = list[location - 1];
location--;
}while(location > 0 &&
list[location - 1].compareTo(temp) > 0);
list[location] = temp;
}
}//end insertionSort
Data Structures Using Java
22
Insertion Sort: Linked List-Based
List
Data Structures Using Java
23
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 Java
24
Insertion Sort: Linked List-Based
List
Data Structures Using Java
25
Insertion Sort: Linked List-Based
List
Data Structures Using Java
26
Insertion Sort: Linked List-Based
List
Data Structures Using Java
27
Insertion Sort: Linked List-Based
List
Data Structures Using Java
28
Analysis: Insertion Sort
Data Structures Using Java
29
Lower Bound on ComparisonBased 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 Java
30
Lower Bound on ComparisonBased Sort Algorithms
Data Structures Using Java
31
Lower Bound on ComparisonBased 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 Java
32
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 Java
33
Data Structures Using Java
34
Quick Sort: Array-Based Lists
Data Structures Using Java
35
Quick Sort: Array-Based Lists
Data Structures Using Java
36
Quick Sort: Array-Based Lists
Data Structures Using Java
37
Quick Sort: Array-Based Lists
Data Structures Using Java
38
Quick Sort: Array-Based Lists
Data Structures Using Java
39
Quick Sort: Array-Based Lists
Data Structures Using Java
40
Quick Sort: Array-Based Lists
private int partition(int first, int last)
{
DataElement pivot;
int index, smallIndex;
swap(first, (first + last) / 2);
pivot = list[first];
smallIndex = first;
for(index = first + 1; index <= last; index++)
if(list[index].compareTo(pivot) < 0)
{
smallIndex++;
swap(smallIndex, index);
}
swap(first, smallIndex);
return smallIndex;
}//end partition
9
Data Structures Using Java
41
Quick Sort: Array-Based Lists
private void swap(int first, int second)
{
DataElement temp;
temp = list[first];
list[first] = list[second];
list[second] = temp;
}//end swap
Data Structures Using Java
42
Quick Sort: Array-Based Lists
private void recQuickSort(int first, int last)
{
int pivotLocation;
if(first < last)
{
pivotLocation = partition(first, last);
recQuickSort(first, pivotLocation - 1);
recQuickSort(pivotLocation + 1, last);
}
}//end recQuickSort
public void quickSort()
{
recQuickSort(0, length - 1);
}//end quickSort
Data Structures Using Java
43
Quick Sort: Array-Based Lists
Data Structures Using Java
44
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 Java
45
Merge Sort Algorithm
Data Structures Using Java
46
Divide
Data Structures Using Java
47
Divide
Data Structures Using Java
48
Merge
Data Structures Using Java
49
Merge
Data Structures Using Java
50
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 Java
51
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 Java
52
Heap Sort: Array-Based Lists
Data Structures Using Java
53
Heap Sort: Array-Based Lists
Data Structures Using Java
54
Heap Sort: Array-Based Lists
Data Structures Using Java
55
Heap Sort: Array-Based Lists
Data Structures Using Java
56
Heap Sort: Array-Based Lists
Data Structures Using Java
57
Heap Sort: Array-Based Lists
Data Structures Using Java
58
Priority Queues: Insertion
Assuming the priority queue is implemented as a
heap:
1. 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.)
2. 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 Java
59
Priority Queues: Remove
Assuming the priority queue is implemented
as a heap, to remove the first element of the
priority queue:
1. Copy the last element of the list into the first array
position.
2. Reduce the length of the list by 1.
3. Restore the heap in the list.
Data Structures Using Java
60
Programming Example: Election
Results
• The presidential election for the student council of your
local university is about to be held. Due to confidentiality,
the chair of the election committee wants to computerize
the voting.
• The chair is looking for someone to write a program to
analyze the data and report the winner.
• The university has four major divisions, and each division
has several departments. For the election, the four
divisions are labeled as region 1, region 2, region 3, and
region 4.
• Each department in each division handles its own voting
and directly reports the votes received by each candidate to
the election committee.
Data Structures Using Java
61
Programming Example: Election
Results
The voting is reported in the following form:
firstName lastName regionNumber numberOfVotes
The election committee wants the output in the following tabular form:
--------------------Election Results-----------------Votes By Region
Candidate Name Rgn#1
Rgn#2
Rgn#3
Rgn#4
Total
-------------- --------------------Buddy Balto
0
0
0
272
272
Doctor Doc
25
71
156
97
349
Ducky Donald
110
158
0
0
268
.
.
.
Winner: ???, Votes Received: ???
Total votes polled: ???
Data Structures Using Java
62
Chapter Summary
• Sorting Algorithms
–
–
–
–
–
Selection sort
Insertion sort
Quick sort
Merge sort
heap sort
• Algorithm analysis
• Priority queues
Data Structures Using Java
63