Chapter 4 - Sorting Algorithm

Trng Cao ng Cng ngh
Th c
DATA STRUCTURES &

ALGORITHMS
Chapter 4: Sorting Algorithms
Teacher: Van Nguyen
E-mail: vannt@tdc.edu.vn
Phone: 0985537687
Goals
At the end of this chapter you should be able to:
Explain interchange sort and its analysis
Explain insertion sort and its analysis
Explain selection sort and its analysis
Explain bubble sort and its analysis
Explain heapsort and its analysis
Explain merge sort and its analysis
Explain quicksort and its analysis
Demo
Analysis and compare the algorithms
11/26/2014
Data structures and algorithms
Chapter Outline
Introduction to Sorting
Sorting Algorithms
Interchange sort
Insertion sort
Selection sort
Bubble sort
Heapsort
Merge sort
Quicksort
Lab
11/26/2014
The Sorting Problem?
Input:
A sequence of n numbers a1, a2, . . . , an
Output:
A permutation (reordering) a1, a2, . . . , an of the input
sequence such that a1 a2 an
11/26/2014
What is Sorting?
Sorting: an operation that segregates items into groups according
to specified criterion
EX:
A={3162134590}
A={0112334569}
11/26/2014
Why Study Sorting Algorithms?
There are a variety of situations that we can encounter
Do we have randomly ordered keys?

Are all keys distinct?
How large is the set of keys to be ordered?
Need guaranteed performance?
Various algorithms are better suited to some of these

situations
11/26/2014
Examples:
Sorting Books in Library (Dewey system)

Sorting Individuals by Height (Feet and
Inches)
Sorting Movies in Blockbuster
(Alphabetical)
Sorting Numbers (Sequential)
11/26/2014
Types of Sorting Algorithms
Interchange sort
Insertion sort
Selection sort
Bubble sort
Heap sort
Merge sort
Quick sort
11/26/2014
Interchange sort Idea

Exchange sorts attempt to improve the
ordering by comparing elements in pairs and
interchanging them if they are not in sorted
order.
This operation is repeated until the table is
sorted.
11/26/2014
Interchange sort - Algorithms

Step 1 : i = 1; // starting from the first row
Step 2 : j = i+1; // find the rear element i
Step 3 :
While j n do
If a[j]< a[i] Swap(a[i], a[j]);
j = j+1;
Step 4 : i = i+1;
o If i < n: Step 2
o Else if End
11/26/2014
10
Interchange sort Example
j
2
12
1
15
11/26/2014
11
j
3
12
2
15
11/26/2014
12
j
4
12
4
15
11/26/2014
13
j
5
12
5
15
11/26/2014
14
12
15
11/26/2014
15
Interchange sort - Code for Algorithms

template <class Item>
void interchangeSort (Item a[], int N )
{
int i, j;
for (i = 0 ; i < N-1; i++)
for (j = i + 1; j < N ; j++)
if (a[j ] < a[i])
swap (a[i], a[j]);
}
11/26/2014
16
Interchange sort Analysis

Running time depends on not only the size of the
array but also the contents of the array.
Best-case:
O(n2)
Array is already sorted in ascending order.
Swap will not be executed.
The number of swap: 0
O(1)
The number of key comparisons: n(n-1)/2
O(n2)
11/26/2014
17
Interchange sort Analysis (cont.)

Worst-case:
O(n2)
Array is in reverse order:
Swap is executed i-1 times, for i = 2,3, , n
The number of moves: n*(n-1)/2
O(n2)
The number of key comparisons: n*(n-1)/2
O(n2)
Average-case: O(n2)
We have to look at all possible initial data
organizations.
So, Interchange Sort is O(n2)
11/26/2014
18
Insertion sort Idea

Insertion sort is a simple sorting algorithm that is
appropriate for small inputs.
Most common sorting technique used by card
players.
The list is divided into two parts: sorted and
unsorted.
In each pass, the first element of the unsorted part is
picked up, transferred to the sorted sublist, and
inserted at the appropriate place.
A list of n elements will take at most n-1 passes to
sort the data.
11/26/2014
19
Insertion sort - Algorithms

Step 1: Starting i = 1 // a[0] is ordered
Step 2: x = a[i]. Find the appropriate position pos in
the segment a[0] ... a [i-1] to insert x.
Step 3: Move the segment a[pos] ... a [i-1] to have a
place to put x on.
Step 4: a[pos] = x
Step 5: i = i + 1
o If i<n: go back to step 2.
o Else: STOP!
11/26/2014
20
Insertion sort - Example
12
15
11/26/2014
21

Insert a2 into (1, 2)
1
pos
2
12
2
15
x
11/26/2014
22

1
pos
3
12
8
15
x
11/26/2014
23

1
pos
4
58
12
15
x
11/26/2014
24

1
pos
5
2
1
12
15
x
11/26/2014
25

1
pos
6
8
6
12
15
x
11/26/2014
26

1
pos
7
5
4
12
8
15
x
11/26/2014
27

1
pos
8
12
15
x
11/26/2014
28
pos
5
11/26/2014
12
15
29
Insertion sort - Code for Algorithms

//increase
void insertionSort(Item a[], int n)
{
int pos;
for (int i = 1; i < n; i++)
{
Item x = a[i];
for (pos=i; pos > 0 && x <= a[pos-1]; pos--)
a[pos] = a[pos-1];
a[pos] = x;
}
}
11/26/2014
30
Insertion sort Analysis

Running time depends on not only the size of the
array but also the contents of the array.
Best-case:
O(n)
Inner loop will not be executed.
The number of moves: 2*(n-1)
O(n)
The number of key comparisons: (n-1)
O(n)
11/26/2014
31
Insertion sort Analysis (cont.)

Worst-case:
O(n2)
Inner loop is executed i-1 times, for i = 2,3, , n
The number of moves: 2*(n-1)+(1+2+...+n-1)=
2*(n-1)+ n*(n-1)/2 O(n2)
The number of key comparisons: (1+2+...+n-1)=
n*(n-1)/2
O(n2)
Average-case: O(n2)
We have to look at all possible initial data
organizations.
So, Insertion Sort is O(n2)
11/26/2014
32
Selection sort Idea

The list is divided into two sublists, sorted and unsorted, which
are divided by an imaginary wall.
We find the smallest element from the unsorted sublist and
swap it with the element at the beginning of the unsorted data.
After each selection and swapping, the imaginary wall between
the two sublists move one element ahead, increasing the
number of sorted elements and decreasing the number of
unsorted ones.
Each time we move one element from the unsorted sublist to
the sorted sublist, we say that we have completed a sort pass.
A list of n elements requires n-1 passes to completely rearrange
the data.
11/26/2014
33
Selection sort Algorithms

Step 1: Starting i = 1
Step 2: Find the smallest element a[min] in the
current range from a[i] to a[N]
Step 3: Swap a[min] and a[i]
Step 4: i = i + 1
o If i <= N-1: go back to step 2
o Else: STOP!
11/26/2014
34
Selection sort Example

Swap(ai, amin)
Find MinPos(1, 8)
min
1
12
15
11/26/2014
35

Swap(ai, amin)
Find MinPos(2, 8)
1
min
2
12
15
11/26/2014
36

Swap(ai, amin)
Find MinPos(3, 8)
1
min
3
12
15
11/26/2014
37

Swap(ai, amin)
Find MinPos(4, 8)
1
min
4
12
15
11/26/2014
38

Swap(ai, amin)
Find MinPos(5, 8)
1
min
5
12
15
11/26/2014
39

Find MinPos(6, 8)
Swap(ai, amin)
7
15
min
6
12
11/26/2014
40

Swap(ai, amin)
Find MinPos(7, 8)
1
min
7
12
8
15
11/26/2014
41
Selection sort - Code for Algorithms

void selectionSort (Item a[], int n)
{
for (int i = 0; i < n-1; i++)
{
int min = i;
for (int j = i+1; j < n; j++)
if (a[j] < a[min]) min = j;
swap(a[i], a[min]);
}
}
template < class Object>
void swap (Object &lhs, Object &rhs)
{
Object tmp = lhs;
lhs = rhs;
rhs = tmp;
}
11/26/2014
42
Selection sort Analysis

In selectionSort function, the outer for loop
executes n-1 times.
We invoke swap function once at each
iteration.
Total Swaps: n-1
Total Moves: 3*(n-1)
(Each swap has
three moves)
11/26/2014
43
Selection sort Analysis (cont.)

The inner for loop executes the size of the
unsorted part minus 1 (from 1 to n-1), and in
each iteration we make one key comparison.
# of key comparisons = 1+2+...+n-1 =
n*(n-1)/2
So, Selection sort is O(n2)
The best case, the worst case, and the
average case of the selection sort algorithm
are same. all of them are O(n2)
11/26/2014
44
Bubble sort Idea

The list is divided into two sublists: sorted and
unsorted.
The smallest element is bubbled from the unsorted
list and moved to the sorted sublist.
After that, the wall moves one element ahead,
increasing the number of sorted elements and
decreasing the number of unsorted ones.
Each time an element moves from the unsorted part
to the sorted part one sort pass is completed.
Given a list of n elements, bubble sort requires up to
n-1 passes to sort the data.
11/26/2014
45
Bubble sort Algorithms

Step 1: Starting i = 1
Step 2: j = N
While j> i do:
o If a[j] <a[j-1]: swap(a[j], a[j-1])
o j=j-1
Step 3: i = i + 1
o If i <= N-1: go back to step 2.
o Else: STOP!
11/26/2014
46
Bubble sort Example
j
8
12
1
15
11/26/2014
47
Bubble sort Example
j
8
12
2
15
11/26/2014
48
Bubble sort Example
j
8
12
4
15
11/26/2014
49
Bubble sort Example
j
8
12
5
15
11/26/2014
50
Bubble sort Example
j
8
12
6
15
11/26/2014
51
Bubble sort Example
j
8
12
8
15
11/26/2014
52
Bubble sort Example
j
8
12
15
11/26/2014
53
Bubble sort - Code for Algorithms

void bubbleSort (Item a[], int n)
{
for (int i = 0; i < n-1; i++)
for (int j = n - 1; j > i; j--)
if (a[j-1] > a[j])
swap(a[j],a[j-1]);
}
11/26/2014
54
Bubble sort Analysis

Best-case:
O(n)

The number of moves: 0
O(1)
The number of key comparisons: (n-1)
O(n)
11/26/2014
55
Bubble sort Analysis (cont.)

Worst-case:
O(n2)

Outer loop is executed n-1 times,
The number of moves: 3*(1+2+...+n-1) = 3 * n*(n-1)/2
O(n2)
The number of key comparisons: (1+2+...+n-1)= n*(n-1)/2
O(n2)
Average-case:
O(n2)
We have to look at all possible initial data organizations.
So, Bubble Sort is O(n2)

11/26/2014
56
Heap sort Heap

What is a Heap?
A heap is also known as a priority queue and can be
represented by a binary tree with the following
properties:
Structure property: A heap is a completely filled
binary tree with the exception of the bottom row,
which is filled from left to right
Heap Order property: For every node x in the
heap, the parent of x greater than or equal to the
value of x. (known as a maxHeap).
11/26/2014
57
Heap sort Heap

53
44
25
15
11/26/2014
21
12
13
18
58
Heap sort Heap

53
44 25
15 21 13 18
12 5
53
44
25
15
21
13
18
12
10 11
For any node i, the following formulas apply:

The index of its parent = i / 2
Index of left child = 2 * i
Index of right child = 2 * i + 1
11/26/2014
59
Heap sort Algorithms

Step 1: Build Heap
Step 2: Swap the first element with the
end element, then reduce size of array to
n-1
Step 3: Continue step 1 and 2 until size of
array is 1
11/26/2014
60
Heap sort Example build heap
12
15
11/26/2014
61
curr
4
12
joint
6
joint
8
15
5
left
11/26/2014
62
curr
2
12
joint
4
joint
5
joint
8
15
left
11/26/2014
63
curr
1
joint
2
joint
3
12
15
left
11/26/2014
64
15
12
11/26/2014
65
Heap sort Example swap and shift
15
12
2
right
Swap(a1, aright)
11/26/2014
66
curr
1
joint
2
joint
3
12
15
right
Shift(a, 1, right)
11/26/2014
67
12
15
right
Swap(a1, aright)
11/26/2014
68
curr
1
joint
2
joint
3
joint
6
12
15
right
Shift(a, 1, right)
11/26/2014
69
12
15
right
Swap(a1, aright)
11/26/2014
70
12
15
12
15
11/26/2014
71
Heap sort - Code for Algorithms

void Shift (Item a[], int left, int right)
{
int x, curr, joint;
curr = left; joint = 2 * curr + 1
x = a[curr];
while (joint <= right)
{
if (joint < right)
if (a[joint] < a[joint+1])
joint = joint+1;
if (a[joint]<x) break;
a[curr] = a[joint];
curr = joint;
joint = 2 * curr + 1;
}
a[curr] = x;
}
11/26/2014
72
Heap sort - Code for Algorithms (cont.)

void CreateHeap (Item a[], int N)
{
int left;
for (left = (N - 1) / 2; left >= 0; left--)
Shift(a, left, N-1);
}
11/26/2014
73
Heap sort - Code for Algorithms (cont.)

void HeapSort (Item a[], int N)
{
int
right;
CreateHeap (a, N);
right = N - 1;
while (right > 0)
{
Swap (a[0],a[right]);
right--;
Shift (a,0,right);
}
}
11/26/2014
74
Heap sort Analysis

Step 1- Build heap, O(n) time complexity
Step 2 and 3 perform n swap and shift operations,
each with O(log(n)) time complexity
total time complexity = O(n log(n))
Pros: fast sorting algorithm, memory efficient,
especially for very large values of n.
Cons: slower of the O(n log(n)) sorting algorithms
11/26/2014
75
Merge sort Idea

Mergesort algorithm is one of two important divideand-conquer sorting algorithms (the other one is
quicksort).
It is a recursive algorithm.
Divides the list into halves,
Sort each halve separately, and
Then merge the sorted halves into one sorted
array.
11/26/2014
76
Merge sort Algorithms

Step 1: Start with k = 1
Step 2: Distribution of array A = a1, a2, , an into
two arrays B, C following:
B= a1, ,ak, a2k+1, , a3k,
C=ak+1, , a2k, a3k+1, , a4k
Step 3: From 2 arrays B, C, we merge each pair
subarray and put into array A.
Step 4: k = k * 2
o If k <n: go back to step 2.
o Else: STOP!
11/26/2014
77
Merge sort Example

k = 1;
1
12
15
11/26/2014
78
Merge sort Example

k = 1;
1
12
15
11/26/2014
79
Merge sort Example

k = 1;
1
12
15
11/26/2014
80
Merge sort Example

k = 1;
1
12
15
11/26/2014
81
Merge sort Example

k = 2;
1
12
15
11/26/2014
82
Merge sort Example

k = 2;
1
12
15
11/26/2014
83
Merge sort Example

k = 2;
1
12
15
11/26/2014
84
Merge sort Example

k = 4;
1
12
15
11/26/2014
85
Merge sort Example

k = 4;
1
12
15
11/26/2014
86
Merge sort Example

k = 4;
1
12
15
11/26/2014
87
Merge sort Example

k = 8;
1
12
15
STOP
Only one subarray
11/26/2014
88
Merge sort Example
12
15
11/26/2014
89
Merge sort - Code for Algorithms

int b[MAX], c[MAX], nb, nc;
int min(int a,int b)

{
if (a > b) return b;
else return a;
}
void MergeSort (Item a[], int N)
{
int k;
for (k = 1; k < N; k *= 2)
{
Distribute(a, N, nb, nc, k);
Merge(a, nb, nc, k);
}
}
11/26/2014
90
Merge sort - Code for Algorithms (cont.)

void Distribute (Item a[], int
N,
int &nb, int &nc, int k)
{
int i, pa, pb, pc;
pa = pb = pc = 0;
while (pa < N)
{
for (i=0; (pa<N) && (i<k); i++, pa++, pb++)
b[pb] = a[pa];
for (i=0; (pa<N) && (i<k); i++, pa++, pc++)
c[pc] = a[pa];
}
nb = pb; nc = pc;
}
11/26/2014
91

void Merge (Item a[], int nb, int nc, int k)
{
int pa, pb, pc;
pa = pb = pc = 0;
while ((pb < nb) && (pc < nc))
MergeSubarr (a, nb, nc, pa, pb, pc, k);
while (pb < nb)
a[pa ++] = b[pb++];
while (pc < nc)
a[pa++] = c[pc++];
}
11/26/2014
92

void MergeSubarr (int a[], int nb, int nc,
int &pa, int &pb, int &pc, int k)
{
int rb, rc;
rb = min (nb, pb + k);
rc = min (nc, pb + k);
while ((pb < rb) && (pc < rc))
if (b[pb] < c[pc])
a[pa++] = b[pb++];
else a[pa++] = c[pc++];
while (pb < rb)
a[pa++] = b[pb++];
while (pc < rc)
a[pa++] = c[pc++];
}
11/26/2014
93
Merge sort Analysis

Merging two sorted arrays of size k
0
k-1
......
k-1
......
2k-1
......
Best-case:
All the elements in the first array are smaller (or larger) than all the
elements in the second array.
The number of moves: 2k + 2k
The number of key comparisons: k
Worst-case:
The number of moves: 2k + 2k
The number of key comparisons: 2k-1
11/26/2014
94
Merge sort Analysis (cont.)

2m
2m-1
level 0 : 1 merge (size 2m-1)
2m-1
level 1 : 2 merges (size 2m-2)

level 2 : 4 merges (size 2m-3)
2m-2 2m-2 2m-2 2m-2

.
.
.
.
.
.
level m-1 : 2m-1 merges (size 20)
20
11/26/2014
.................
20
level m
95

Worst-case
The number of key comparisons:
= 20*(2*2m-1-1) + 21*(2*2m-2-1) + ... + 2m-1*(2*20-1)
= (2m - 1) + (2m - 2) + ... + (2m 2m-1)
( m terms )
= m*2m
= m*2m 2m 1
Using m = log n
= n * log2n n 1
O (n * log2n )
11/26/2014
96

Mergesort is extremely efficient algorithm with
respect to time.
Both worst case and average cases are O (n * log2n )
But, mergesort requires an extra array whose size

equals to the size of the original array.
If we use a linked list, we do not need an extra array
But, we need space for the links
And, it will be difficult to divide the list into half ( O(n) )
11/26/2014
97
Quicksort Idea
Like mergesort, Quicksort is also based on
the divide-and-conquer paradigm.
But it uses this technique in a somewhat opposite
manner,
as all the hard work is done before the recursive
calls.
It works as follows:
1. First, it partitions an array into two parts,
2. Then, it sorts the parts independently,
3. Finally, it combines the sorted subsequences by
a simple concatenation.
11/26/2014
98
Quicksort Idea (cont.)

The quick-sort algorithm consists of the following three
steps:
1. Divide: Partition the list.
To partition the list, we first choose some element from the
list for which we hope about half the elements will come
before and half after. Call this element the pivot.
Then we partition the elements so that all those with values
less than the pivot come in one sublist and all those with
greater values come in another.
2. Recursion: Recursively sort the sublists separately.

3. Conquer: Put the sorted sublists together.
11/26/2014
99
Quicksort Algorithms
Step 1: If left>=right: STOP
Step 2: Choose any element a[k] is pivot (l k r):
x = a [k]; i = l; j = r;
Step 3: Detect and correct pair of elements a[i], a[j] is the
wrong position:
o Step 3a: while (a [i] <x) i ++;
o Step 3b: while (a [j]> x) j--;
o Step 3c: If i <j Swap(a [i], a [j]);
Step 4: If i <j: Repeat Step 3.

Else: Go to Step 4
Step 5: Quicksort for aleftaj
Step 6: Quicksort for aiaright
11/26/2014
100
Quicksort Example
Partition
X
i
1
j
8
12
15
right
left
11/26/2014
STOP
STOP
Not less than X
Not greater than X
101
Quicksort Example
Partition
X
i
2
j
6
12
15
right
left
11/26/2014
STOP
STOP
Not less than X
Not greater than X
102
Quicksort Example
j
3
i
5
12
15
right
left
11/26/2014
103
Quicksort Example
Partition
X
1
i
5
j
8
12
15
right
left
11/26/2014
STOP
STOP
Not less than X
Not greater than X
104
Quicksort Example
j
5
6
left
11/26/2014
i
6
12
15
right
105
Quicksort Example
12
15
11/26/2014
106
Quicksort - Code for Algorithms

void QuickSort (Item a[], int left, int right)
{
int i, j, x;
if (left right) return;
x = a[(left+right) / 2];
i = left; j = right;
while (i < j)
{
while (a[i] < x) i++;
while (a[j] > x) j--;
if (i <= j)
{
Swap (a[i], a[j]);
i++ ; j--;
}
}
QuickSort (a, left, j);
QuickSort (a, i, right);
}
11/26/2014
107
Quicksort Analysis
Worst Case: (assume that we are selecting the mid element as
pivot)
The pivot divides the list of size n into two sublists of sizes 0 and n-1.
The number of key comparisons
= n-1 + n-2 + ... + 1
= n2/2 n/2
O(n2)
The number of swaps =
= n-1 + n-1 + n-2 + ... + 1
swaps outside of the for loop
= n2/2 + n/2 - 1
swaps inside of the for loop
O(n2)
So, Quicksort is O(n2) in worst case

11/26/2014
108
Quicksort Analysis (cont.)

Quicksort is O(n*log2n) in the best case and average
case.
Quicksort is slow when the array is sorted and we
choose the first element as the pivot.
Although the worst case behavior is not so good, its
average case behavior is much better than its worst
case.
So, Quicksort is one of best sorting algorithms using key
comparisons.
11/26/2014
109
Question
11/26/2014
110
QUESTIONS AND EXERCISES

1. Write a method:
public static bool isSorted( int[] array, int n)
that returns true if array is sorted; otherwise it returns false.
2. Write a recursive bubble sort on a double array.
3. Write a recursive insertion sort on a double array.
4. Many operations can be performed faster on sorted than on
unsorted data. For which of the following operations is this the case?
(a) Finding an item with minimum value.
(b) Computing an average of values.
(c) Finding the middle value (the median).
(d) Finding the value that appears most frequently in the data.
(e) Finding the distinct elements of an array.
(f) Finding a value closest to a given value.
(g) Finding whether one word is an anagram(i.e., it contains the same
letters) as another word.
(example:plum and lump)
11/26/2014
111
QUESTIONS AND EXERCISES (cont.)

5. Class Student have 2 property name and
studentNo. Rewrite some of the sorting methods we
have studied such that each sorts an Object array of
Student objects by name or studentNo.
6. Show the contents of the following integer array:
43, 7, 10, 23, 18, 4, 19, 5, 66, 14
when the array is sorted in ascending order using:
(a) bubble sort, (b) selection sort, (c) insertion sort
(d) Interchange sort, (e) heap sort, (f) merge sort, (g)
quicksort
11/26/2014
112
QUESTIONS AND EXERCISES (cont.)

7. In our implementation of bubble sort, an array was
scanned bottom-up to bubble up the smallest element.
What modifications are needed to make it work topdown to bubble down the largest element?
8. A cocktail shaker sort is a modification of bubble sort
in which the direction of bubbling changes in each
iteration: In one iteration, the smallest element is
bubbled up; in the next, the largest is bubbled down; in
the next the second smallest is bubbled up; and so
forth. Implement this algorithm.
9. Explain why insertion sort works well on partially
sorted arrays.
11/26/2014
113
Thank you !
11/26/2014
114

Chapter 4 - Sorting Algorithm

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Chapter 4 - Sorting Algorithm

Încărcat de

Drepturi de autor:

Formate disponibile

Trng Cao ng Cng ngh

DATA STRUCTURES &

Data structures and algorithms

Data structures and algorithms

Data structures and algorithms

Data structures and algorithms

Do we have randomly ordered keys?

Various algorithms are better suited to some of these

Data structures and algorithms

Sorting Books in Library (Dewey system)

Data structures and algorithms

Data structures and algorithms

Interchange sort Idea

Data structures and algorithms

Interchange sort - Algorithms

Data structures and algorithms

Interchange sort Example

Data structures and algorithms

Interchange sort Example

Data structures and algorithms

Interchange sort Example

Data structures and algorithms

Interchange sort Example

Data structures and algorithms

Interchange sort Example

Data structures and algorithms

Interchange sort - Code for Algorithms

Data structures and algorithms

Interchange sort Analysis

Data structures and algorithms

Interchange sort Analysis (cont.)

Data structures and algorithms

Insertion sort Idea

Data structures and algorithms

Insertion sort - Algorithms

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Example

Data structures and algorithms

Insertion sort - Code for Algorithms

Data structures and algorithms

Insertion sort Analysis

Data structures and algorithms

Insertion sort Analysis (cont.)

Data structures and algorithms

Selection sort Idea

Data structures and algorithms

Selection sort Algorithms