Data Structures Using C++ 2E

Chapter 10
Sorting Algorithms
 Objectives

• Learn the various sorting algorithms

• Explore how to implement selection sort, insertion
sort, Shellsort, quicksort, mergesort, and heapsort
(done)
• Discover how the sorting algorithms discussed in
this chapter perform
• Learn how priority queues are implemented (done)

Data Structures Using C++ 2E 2

 Sorting Algorithms

• Several types in the literature

– Discussion includes most common algorithms
• Analysis
– Provides a comparison of algorithm performance
• Functions implementing sorting algorithms
– Included as public members of related class

Data Structures Using C++ 2E 3

 Selection Sort and Insertion Sort
• Selection Sort:
• Find the smallest card
round by round

• Insertion Sort:
• Keep the cards in your
left hand sorted

Data Structures Using C++ 2E 4

 Selection Sort: Array-Based Lists

• List sorted by selecting elements in the list

– Select elements one at a time
– Move elements to their proper positions
• Selection sort operation
– Find location of the smallest element in unsorted list
portion
• Move it to top of unsorted portion of the list
– First time: locate smallest item in the entire list
– Second time: locate smallest item in the list starting
from the second element in the list, and so on

Data Structures Using C++ 2E 5

 FIGURE 10-1 List of 8 elements

FIGURE 10-2 Elements of list during the first iteration

FIGURE 10-3 Elements of list during the second iteration

Data Structures Using C++ 2E 6
 Selection Sort: Array-Based Lists
(cont’d.)
• Selection sort steps
– In the unsorted portion of the list
• Find location of smallest element
• Move smallest element to beginning of the unsorted list
• Keep track of unsorted list portion with a for loop

Data Structures Using C++ 2E 7

 Selection Sort: Array-Based Lists
(cont’d.)
• Given: starting index, first, ending index, last
– C++ function returns index of the smallest element in
list[first]...list[last]

Data Structures Using C++ 2E 8

 Selection Sort: Array-Based Lists
(cont’d.)
• Function swap
• Definition of function selectionSort

Data Structures Using C++ 2E 9

 Selection Sort: Array-Based Lists
(cont’d.)
• Add functions to implement selection sort in the
definition of class arrayListType

Data Structures Using C++ 2E 10

 Analysis: Selection Sort

• Search algorithms
– Concerned with number of key (item) comparisons
• Sorting algorithms
– Concerned with number of key comparisons and
number of data movements
• Analysis of selection sort
– Function swap
• Number of item assignments: 3(n-1)
– Function minLocation
• Number of key comparisons of O(n2)

Data Structures Using C++ 2E 11

 Insertion Sort: Array-Based Lists

• Attempts to improve high selection sort key

comparisons
• Sorts list by moving each element to its proper place
• Given list of length eight

FIGURE 10-4 list

Data Structures Using C++ 2E 12

 Insertion Sort: Insert

• Three strategies to find proper place

– Search from rear
– Search from front
– Binary search

Data Structures Using C++ 2E 13

 Insertion Sort: Array-Based Lists
(cont’d.)
• Elements list[0], list[1], list[2], list[3]
in order
• Consider element list[4]
– First element of unsorted list

FIGURE 10-5 list elements while moving list[4] to its proper place

Data Structures Using C++ 2E 14

 Insertion Sort: Array-Based Lists
(cont’d.)
• Array containing list divided into two sublists
– Upper and lower
• Index firstOutOfOrder
– Points to first element in the lower sublist

Data Structures Using C++ 2E 15

 Insertion Sort: Array-Based Lists
(cont’d.)
• length = 8
• Initialize firstOutOfOrder to one

FIGURE 10-6 firstOutOfOrder = 1

Data Structures Using C++ 2E 16

 Insertion Sort: Array-Based Lists
(cont’d.)
• list[firstOutOfOrder] = 7
• list[firstOutOfOrder - 1] = 13
– 7 < 13
• Expression in if statement evaluates to true
– Execute body of if statement
• temp = list[firstOutOfOrder] = 7
• location = firstOutOfOrder = 1
– Execute the do...while loop
• list[1] = list[0] = 13
• location = 0

Data Structures Using C++ 2E 17

 Insertion Sort: Array-Based Lists
(cont’d.)
• do...while loop terminates
– Because location = 0
• Copy temp into list[location] (list[0])

FIGURE 10-7 list after the first iteration of insertion sort

Data Structures Using C++ 2E 18

 Insertion Sort: Array-Based Lists
(cont’d.)
• Suppose list given in Figure 10-8(a)
– Walk through code

FIGURE 10-8 list elements while moving list[4] to its proper place

Data Structures Using C++ 2E 19

 Insertion Sort: Array-Based Lists
(cont’d.)
• Suppose list given in Figure 10-9
– Walk through code

FIGURE 10-9 First out-of-order element is at position 5

Data Structures Using C++ 2E 20

 Insertion Sort: Array-Based Lists
(cont’d.)
• C++ function implementing previous algorithm

Data Structures Using C++ 2E 21

 Insertion Sort: Linked List-Based Lists
• If list stored in an array
– Traverse list in either direction using index variable
• If list stored in a linked list
– Traverse list in only one direction
• Starting at first node: links only in one direction

FIGURE 10-10 Linked list

Data Structures Using C++ 2E 22

 Insertion Sort: Linked List-Based Lists
(cont’d.)
• firstOutOfOrder
– Pointer to node to be moved to its proper location
• lastInOrder
– Pointer to last node of the sorted portion of the list

FIGURE 10-11 Linked list and pointers lastInOrder

and firstOutOfOrder

Data Structures Using C++ 2E 23

 Insertion Sort: Linked List-Based Lists
(cont’d.)
• Compare firstOutOfOrder info with first node
info
– If firstOutOfOrder info smaller than first node
info
• firstOutOfOrder moved before first node
– Otherwise, search list starting at second node to find
location where to move firstOutOfOrder
• Search list using two pointers
– current
– trailCurrent: points to node just before current
• Handle any special cases

Data Structures Using C++ 2E 24

 Insertion Sort: Linked List-Based Lists
(cont’d.)

Data Structures Using C++ 2E 25

 Analysis: Insertion Sort

TABLE 10-1 Average-case behavior of the selection sort and

insertion sort for a list of length n

Data Structures Using C++ 2E 26

 Insertion Sort: Best case and worst
• Best case: sorted array
– Search from rear: (n-1) comparisons and 0 data
movement
• Worst case: reversely sorted array
– Search from rear: (n-1) + (n-2) + (n-3) + … + 1
comparisons and movements

Data Structures Using C++ 2E 27

 Shellsort
• Take advantage of the best case of insertion sort
– Use global jumps to make the input quickly close
to an almost-sorted situation
– Jumps are controlled by step sizes
• e.g. 30, 13, 5, 3, 1
• The final step will be an insertion sort, where
the input is almost sorted.

Data Structures Using C++ 2E 28

 Shellsort

• Reduces number of item movements in insertion

sort by modifying it
– Introduced in 1959 by D.E. Shell
– Also known as diminishing-increment sort
• List elements viewed as sublists at a particular
distance
– Each sublist sorted
• Elements far apart move closer to their final position

Data Structures Using C++ 2E 29

 Shellsort (cont’d.)

FIGURE 10-19 Lists during Shellsort

Data Structures Using C++ 2E 30
 Shellsort (cont’d.)
• Figure 10-19
– Sort elements at a distance of 7, 4, 1
• Called increment sequence
• Desirable to use as few increments as possible
• D.E. Knuth recommended increment sequence
– 1, 4, 13, 40, 121, 364, 1093, 3280. . . .
• Ratio between successive increments: about one-third
• ith increment = 3 • (i – 1)th increment + 1
• Certain increment sequences must be avoided
– 1, 2, 4, 8, 16, 32, 64, 128, 256. . . .
• Bad performance
Data Structures Using C++ 2E 31
 Shellsort (cont’d.)

• Function implementing Shellsort algorithm

Data Structures Using C++ 2E 32

 Shellsort (cont’d.)

• Function shellSort
– Uses function intervalInsertionSort
• Modified version of insertion sort for array-based lists
• intervalInsertionSort
– Sublist starts at variable begin
– Increment between successive elements given by
variable inc instead of one
• Analysis of Shellsort
– Difficult to obtain

Data Structures Using C++ 2E 33