Data Structures
Sorting
8 20 8 5 10 7
Turkan Ahmed
Computer Eng. Dept. , Collage of Eng., University of Mosul
2
What is Sorting?
Sorting: an operation that segregates items
into groups according to specified criterion.
A={3162134590}
A={0112334569}
• Internal Sort
– The data to be sorted is all stored in the computer’s
main memory.
• External Sort
– Some of the data to be sorted might be stored in some
external, slower, device.
Why Sort and Examples
3
Consider:
● Sorting Books in Library (Dewey system)
● Sorting Individuals by Height (Feet and Inches)
● Sorting Movies in Blockbuster (Alphabetical)
● Sorting Numbers (Sequential)
General Sorting
4
Assumptions
data in linear data structure
availability of comparator for elements
availability of swap routine (or shift )
no knowledge about the data values
Swap (in an Array)
5
public static void swap
(int data[], int i, int j)
{
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
Types of Sorting Algorithms
6
There are many, many different types of sorting
algorithms, but the primary ones are:
Simple Sort Algorithms
● Bubble Sort Complex Sort Algorithms
● Selection Sort
● Quick Sort
● Insertion Sort
● Radix Sort
● Swap Sort
●Merge Sort
● Shell Sort
● Heap Sort
Bubble Sort
7
• list[0]...list[n - 1]
– List of n elements, indexed 0 to n - 1
Bubble Sort
8
• Series of n - 1 iterations
– Successive elements list[index] and
list[index + 1] of list are compared
– If list[index] > list[index + 1]
• Elements list[index] and list[index + 1] are
swapped
• Smaller elements move toward the top
• Larger elements move toward the bottom
Bubble Sort
9
Bubble Sort
10
Bubble Sort
11
Bubble Sort
12
Bubble Sort Example
13
Start – Unsorted
Compare, swap (0, 1)
Compare, swap (1, 2)
Compare, no swap
Compare, noswap
Compare, swap (4, 5)
99 in position
Bubble Sort Example
14
Pass 2
swap (0, 1)
no swap
no swap
swap (3, 4)
21 in position
Bubble Sort Example
15
Pass 3
no swap
no swap
swap (2, 3)
12 in position, Pass 4
no swap
swap (1, 2)
8 in position, Pass 5
swap (1, 2)
Done
Bubble Sort Algorithm
16
Bubble Sort – Algorithm Complexity
17
Time consuming operations
compares, swaps.
#Compares
a for loop embedded inside a while loop
(n-1)+(n-2)+(n-3) …+1 , or O(n2)
#Swaps
inside a conditional -> #swaps data dependent !!
Best Case 0, or O(1)
Worst Case (n-1)+(n-2)+(n-3) …+1 , or O(n2)
Space
size of the array
an in-place algorithm
18
Smart Bubble Sort
Simplest sorting algorithm
Idea:
1. Set flag = false
2. Traverse the array and compare pairs of two
elements
1.1 If E1 E2 - OK
1.2 If E1 > E2 then Switch(E1, E2) and set flag = true
3. If flag = true goto 1.
What happens?
Smart Bubble Sort Algorithm
19
void bubbleSort (Array S, length n) {
boolean isSorted = false;
while(!isSorted) {
isSorted = true;
for(i = 0; i<n; i++) {
if(S[i] > S[i+1]) {
int aux = S[i];
S[i] = S[i+1];
S[i+1] = aux;
isSorted = false;
}
}
}
Bubble Sort Function
20
// This function is the "dumb" Bubble Sort, which continues to
// compare array elements after the data is already sorted.
void BubbleSort1(int Array[],int N)
{
int P,Q,T;
for (P = 1; P < N; P++)
{
for (Q = 0; Q < N-P; Q++)
if (Array[Q]>Array[Q+1])
{
T = Array[Q]; Array[Q] = Array[Q+1]; Array[Q+1] = T;
}
for (Q = 0; Q < N; Q++)
cout<<Array[Q]<<" ";
cout<<endl;
}
}
Smart Bubble Sort Function
21
// This function is the "smart" Bubble Sort, which stops to check
// if array elements need to be swapped after the list is already sorted.
void BubbleSort2(int Array[],int N)
{ int Q,T;
int Sorted=0;
int P = 0;
do {
Sorted = 1;
P++;
for (Q = 0; Q < N-P; Q++)
if (Array[Q] > Array[Q+1])
{ Sorted = 0;
T = Array[Q];
Array[Q] = Array[Q+1];
Array[Q+1] = T; }
} while (!Sorted);
}
22
Sorting in General
The efficiency of our algorithms is
dependent on the
number of comparisons we have to make with
our keys.
In addition, we will learn that sorting will also
depend on how frequently we must move
items around.
Selection Sort
23
• Idea:
– Find the smallest element in the array
– Exchange it with the element in the first position
– Find the second smallest element and exchange it with
the element in the second position
– Continue until the array is sorted
• Disadvantage:
– Running time depends only slightly on the amount of order
in the file
Selection Sort
24
Rearrange the list by selecting an element in the list and moving it to its
proper position
Finds the location of the smallest element in the unsorted portion of the list
Moves it to the top of the unsorted portion of the list
Selection Sort
25
Selection Sort
26
Selection Sort
27
5 5 5 5 5 5 5
7 7 7 7 7 7 7
24 16 16 16 16 16 16
30 30 24 24 24 24 24
62 62 62 30 30 30 30
45 45 45 45 45 45 45
16 24 30 62 62 62 55
55 55 55 55 55 55 62
Selection Sort
28
• In the unsorted portion of the list:
– Find the location of the smallest element
– Move the smallest element to the beginning of the
unsorted list
Selection Sort Algorithm
29
Selection Sorting (Example)
30
Selection Sorting Function
31
// The Selection Sort function uses the same principle as the
// Bubble Sort. One major improvement is used by tracking the largest element during
// the comparison pass.
// The result is that the Selection Sort only makes one swap for each pass.
void SelectionSort(int Array[],int N)
{
int P,Q,T;
int Smallest;
for (P = 0; P < N; P++)
{
Smallest = P;
for (Q = P+1; Q < N; Q++)
if (Array[Q] < Array[Smallest])
Smallest = Q;
if (Array[P] != Array[Smallest])
{
T = Array[P];
Array[P] = Array[Smallest];
Array[Smallest] = T;
}
} }
Insertion Sort
32
Idea: like sorting a hand of playing cards
Start with an empty left hand and the cards facing down on
the table.
Remove one card at a time from the table, and insert it into
the correct position in the left hand
compare it with each of the cards already in the hand, from right
to left
The cards held in the left hand are sorted
these cards were originally the top cards of the pile on the table
Insertion Sort
To insert 12, we need to
make room for it by moving
first 36 and then 24.
33
Insertion Sort
34
Insertion Sort
35
Insertion Sort
36
input array
5 2 4 6 1 3
at each iteration, the array is divided in two sub-arrays:
left sub-array right sub-array
unsorted
sorted
36
Insertion Sort
37
37
38
Insertion Sort
Reduces number of key comparisons made
in selection sort
Can be applied to both arrays and linked
lists.
Sorts list by
Finding first unsorted element in list
Moving it to its proper position
Insertion Sort: Array-Based Lists
39
Insertion Sort: Array-Based Lists
40
Insertion Sort: Array-Based Lists
41
Insertion Sort: Array-Based Lists
42
Insertion Sort: Functions
43
// This Insertion Sort uses an array to store sorted data.
// A Linear Search function is used first to find the proper
// insertion index, followed by an InsertItem function that
// shifts the array elements and inserts the new number.
void LinearSearch(int Array[],int SearchNumber,int N, int
&Index)
{
Index = 0;
while (Index < N && SearchNumber > Array[Index])
Index++;
}
Insertion Sort: Functions
44
void InsertItem(int Array[],int SearchNumber,int N,int Index)
{
int K;
for (K = N-1; K > Index; K--)
Array[K] = Array[K-1];
Array[Index] = SearchNumber;
}
Insertion Sort: Functions
45
void InsertSort(int Array[],int N)
{ int Index,K;
int Size;
int Nr;
for (K = 1; K < N; K++)
{
Size = K + 1;
Nr=Array[K];
LinearSearch(Array,Nr,Size,Index);
InsertItem(Array,Nr,Size,Index);
} }
Comparison of Quadratic Sorts
46
Comparisons Exchanges
Best Worst Best Worst
Selection O(n²) O(n²) O(1) O(n)
Sort
Bubble O(n) O(n²) O(1) O(n²)
Sort
Insertion O(n) O(n²) O(1) O(n²)
Sort
Exercise
47
Why is the smart bubble sort called smart?
What is the sorting mechanism of the
bubble sort ?
What is the sorting mechanism of the
Selection sort ?
What is the sorting mechanism of the
Insertion sort ?
