CSE373: Data Structures & Algorithms Lecture 5: Dictionaries ...
Lecture 13 data structures and algorithms
-
Upload
aakash-singhal -
Category
Education
-
view
849 -
download
4
Transcript of Lecture 13 data structures and algorithms
![Page 1: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/1.jpg)
1
Data Structure and Algorithm (CS 102)
Ashok K Turuk
![Page 2: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/2.jpg)
2
Sorting
Sorting refers to the operation of arranging data in some order such as increasing or decreasing with numerical data or alphabetically with character data
![Page 3: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/3.jpg)
3
Complexity of Sorting Algorithm
The complexity of a sorting algorithm measures the running time as a function of the number on n of items to be sorted
![Page 4: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/4.jpg)
4
Complexity of Sorting Algorithm
Each sorting algorithm S will be made up of the following operations, where A1, A2 , ……, An contain the items to be sorted and B is an auxiliary location:
(a) Comparisons, which test whether Ai < Aj or test Ai < B
(b) Interchange, which switch the content of Ai and Aj or of Ai and B
(c) Assignments, which set B := Ai and then set Aj := B or Set Aj := Ai
![Page 5: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/5.jpg)
5
Sorting
Algorithms are divided into two categories:
Internal Sorts
and
External sorts.
![Page 6: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/6.jpg)
6
SortingInternal Sort:
Any sort algorithm which uses main memory exclusively during the sort.
This assumes high-speed random access to all memory.
![Page 7: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/7.jpg)
7
Sorting
External Sort:
Any sort algorithm which uses external memory, such as tape or disk, during the sort.
![Page 8: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/8.jpg)
8
Sorting
Note:Algorithms may read the initial values
from magnetic tape or write sorted values to disk, but this is not using external memory during the sort. Note that even though virtual memory may mask the use of disk, sorting sets of data much larger than main memory may be much faster using an explicit external sort.
![Page 9: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/9.jpg)
9
Sorting
Sort Stable
A sort algorithm is said to be “stable” if multiple items which compare as equal will stay in the same order they were in after a sort.
![Page 10: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/10.jpg)
10
Internal Sorting
Bubble Sort
The oldest and simplest sort in use.
Unfortunately, also the slowest.
Works by comparing each item in the list with the item next to it, and swapping them if required.
![Page 11: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/11.jpg)
11
Bubble Sort
The algorithm repeats this process until it makes a pass all the way through the list without swapping any items.
This causes larger values to "bubble" to the end of the list while smaller values "sink" towards the beginning of the list.
![Page 12: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/12.jpg)
12
Bubble Sort
Suppose the list of number A[1], [2], A[3], …, A[N] is in memory. Algorithm works as follows.
[1] Compare A[1] and A[2], arrange them in the desired order so that A[1] < A[2]. Then Compare A[2] and A[3], arrange them in the desired order so that A[2] < A[3]. Continue until A[N-1] is compared with A[N], arrange them so that A[N-1] < A[N].
![Page 13: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/13.jpg)
13
Bubble Sort
[2] Repeat Step 1, Now stop after comparing and re-arranging A[N-2] and A[N-1].
[3] Repeat Step 3, Now stop after comparing and re-arranging A[N-3] and A[N-2].
.
.[N-1] Compare A[1] and A[2] and arrange them in
sorted order so that A[1] < A[2].
After N-1 steps the list will be sorted in increasing order.
![Page 14: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/14.jpg)
14
A Bubble Sort Example
654321
Compare
![Page 15: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/15.jpg)
15
A Bubble Sort Example
564321
Swap
![Page 16: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/16.jpg)
16
A Bubble Sort Example
564321
Compare
![Page 17: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/17.jpg)
17
A Bubble Sort Example
546321
Swap
![Page 18: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/18.jpg)
18
A Bubble Sort Example
546321
Compare
![Page 19: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/19.jpg)
19
A Bubble Sort Example
543621
Swap
![Page 20: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/20.jpg)
20
A Bubble Sort Example
543621
Compare
![Page 21: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/21.jpg)
21
A Bubble Sort Example
543261
Swap
![Page 22: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/22.jpg)
22
A Bubble Sort Example
543261
Compare
![Page 23: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/23.jpg)
23
A Bubble Sort Example
543216
Swap
As you can see, the largest numberhas “bubbled” down, or sunk to the bottom of the List after the first pass through the List.
![Page 24: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/24.jpg)
24
A Bubble Sort Example
543216
Compare
For our second pass through the List, we start by comparing these first two elements in the List.
![Page 25: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/25.jpg)
25
A Bubble Sort Example
453216
Swap
![Page 26: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/26.jpg)
26
A Bubble Sort Example
453216
Compare
![Page 27: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/27.jpg)
27
A Bubble Sort Example
435216
Swap
![Page 28: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/28.jpg)
28
A Bubble Sort Example
435216
Compare
![Page 29: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/29.jpg)
29
A Bubble Sort Example
432516
Swap
![Page 30: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/30.jpg)
30
A Bubble Sort Example
432516
Compare
![Page 31: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/31.jpg)
31
A Bubble Sort Example
432156
Swap
At the end of the second pass, we stop at element number n - 1, because the largest element in the List is already in the last position. This places the second largest element in the second to last spot.
![Page 32: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/32.jpg)
32
A Bubble Sort Example
432156
Compare
We start with the first two elements again at the beginning of the third pass.
![Page 33: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/33.jpg)
33
A Bubble Sort Example
342156
Swap
![Page 34: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/34.jpg)
34
A Bubble Sort Example
342156
Compare
![Page 35: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/35.jpg)
35
A Bubble Sort Example
324156
Swap
![Page 36: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/36.jpg)
36
A Bubble Sort Example
324156
Compare
![Page 37: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/37.jpg)
37
A Bubble Sort Example
321456
Swap
At the end of the third pass, we stop comparing and swapping at element number n - 2.
![Page 38: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/38.jpg)
38
A Bubble Sort Example
321456
Compare
The beginning of the fourth pass...
![Page 39: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/39.jpg)
39
A Bubble Sort Example
231456
Swap
![Page 40: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/40.jpg)
40
A Bubble Sort Example
231456
Compare
![Page 41: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/41.jpg)
41
A Bubble Sort Example
213456
Swap
The end of the fourth pass stops at element number n - 3.
![Page 42: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/42.jpg)
42
A Bubble Sort Example
213456
Compare
The beginning of the fifth pass...
![Page 43: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/43.jpg)
43
A Bubble Sort Example
123456
Swap
The last pass compares only the first two elements of the List. After this comparison and possible swap, the smallest element has “bubbled” to the top.
![Page 44: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/44.jpg)
44
What “Swapping” Means654321
TEMP
Place the first element into the Temporary Variable.
6
![Page 45: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/45.jpg)
45
What “Swapping” Means554321
TEMP
Replace the first element with the second element.
6
![Page 46: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/46.jpg)
46
What “Swapping” Means564321
TEMP
Replace the second element with the Temporary Variable.
6
![Page 47: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/47.jpg)
47
Bubble SortDATA is an array with N elements[1] Repeat Step 2 and 3 for K =1 to N-1[2] Set PTR :=1 [3] Repeat While PTR <= N –K
(a) If DATA[PTR] > DATA[PTR+1]Interchange DATA[PTR] and DATA[PTR + 1]
(b) Set PTR = PTR + 1[4] Exit
![Page 48: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/48.jpg)
48
Analysis of Bubble Sort
f(n) = (n-1) + (n-2) + …. + 2+1 = n(n-1)/ 2
= O(n2 )
![Page 49: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/49.jpg)
49
Quick SortQuick sort is an algorithm of the
divide-and-conquer type
The problem of sorting a set is reduced to the problem of sorting two smaller sets.
![Page 50: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/50.jpg)
50
Quick Sort Approach
xy ≤ x y ≥ x
A1 n
A
Pivot element
Sort recursively Sort recursively
![Page 51: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/51.jpg)
51
Quick Sort
To select the pivot
Select the first number FIRST in the list, beginning with the last number in the list, scan from right to left, comparing with each number and stopping at the first number less than FIRST. Then interchange the two number.
![Page 52: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/52.jpg)
52
44, 33, 11, 55, 77, 90, 40, 60, 99, 22, 88, 6622, 33, 11, 55, 77, 90, 40, 60, 99, 44, 88, 66
22, 33, 11, 44, 77, 90, 40, 60, 99, 55, 88, 66
22, 33, 11, 40, 77, 90, 44, 60, 99, 55, 88, 66
![Page 53: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/53.jpg)
53
22, 33, 11, 40, 44, 90, 77, 60, 99, 55, 88, 66
22, 33, 11, 40, 44, 90, 77, 60, 99, 55, 88, 66
First Sublist Second SubList
![Page 54: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/54.jpg)
54
Quick Sort Algorithm
Input: Unsorted sub-array A[first..last]Output: Sorted sub-array A[first..last]
QUICKSORT (A, first, Last)if first < last
then loc← PARTITION(A, first, last)QUICKSORT (A, first, loc-1)QUICKSORT (A, loc+1, last)
![Page 55: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/55.jpg)
55
Partition AlgorithmInput: Sub-array A[first..last]Output: Sub-array A[first..loc] where each element of
A[first..loc-1] is ≤ to each element of A[(q+1)..r]; returns the index loc
PARTITION (A, first, last)1 x ← A[first]2 i ← first -13 j ← last +1 4 while TRUE5 repeat j ← j - 16 until A[j] ≤ x 7 repeat i ← i + 1 8 until A[i] ≥ x9 if i < j10 then exchange A[i] ↔A[j]11 else return j
![Page 56: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/56.jpg)
56
Insertion SortAn array A with N elements A[1], A[2]
… A[N] is in memory
Insertion Sort scan A from A[1] to A[N] inserting each elements A[k] into its proper position in the previously sorted subarray A[1], A[2], …. A[K-1]
![Page 57: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/57.jpg)
57
Pass 1: A[1] by itself is trivially sortedPass 2: A[2] is inserted either before or
after A[1] so that A[1], A[2] is sortedPass 3: A[3] is inserted in its proper
place in A[1], A[2], that is before A[1], between A[1] and A[2] or after A[2] so that A[1], A[2], A[3] is sorted.
![Page 58: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/58.jpg)
58
Pass 4: A[4] is inserted in its proper place in A[1], A[2], A[3] so that A[1], A[2], A[3], A[4] is sorted.
.
.Pass N: A[N] is inserted in its proper
place in A[1], A[2], A[3], .. A[N-1] so that A[1], A[2], A[3], A[4] , A[N] is sorted.
![Page 59: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/59.jpg)
59
Insertion Sort Example
Sort an array A with 8 elements
77, 33, 44, 11, 88, 66, 55
![Page 60: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/60.jpg)
60
Insertion Sort
Pass
A[0]
A[1]
A[2]
A[3]
A[4]
A[5]
A[6]
A[7]
A[8]
K=1
-∞ 77 33 44 11 88 22 66 55
K=2
-∞ 77 33 44 11 88 22 66 55
K=3
-∞ 33 77 44 11 88 22 66 55
K=4
-∞ 33 44 77 11 88 22 66 55
K=5
-∞ 11 33 44 77 88 22 66 55
K=6
-∞ 11 33 44 77 88 22 66 55
K=7
-∞ 11 22 33 44 77 88 66 55
K=8
-∞ 11 22 33 44 66 77 88 55
Sorted
-∞ 11 22 33 44 55 66 77 88
![Page 61: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/61.jpg)
61
Insertion AlgorithmThis algorithm sort an array with N
elements[1] Set A[0] = -∞ [Initialize a delimiter][2] Repeat Steps 3 to 5 for K = 2, 3, …, N[3] Set TEMP = A[K] and PTR = K-1[4] Repeat while TEMP < A[PTR]
(a) Set A[PTR+1] = A[PTR](b) Set PTR = PTR -1
[5] Set A[PTR+1] = TEMP[6] Exit
![Page 62: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/62.jpg)
62
Complexity of Insertion Sort
Worst Case: O(n2)
Average Case: O(n2)
![Page 63: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/63.jpg)
63
Selection SortSuppose an array A with N elements is
in memory. Selection sort works as follows
First find the smallest element in the list and put it in the first position. Then, find the second smallest element in the list and put it in the second position and so on.
![Page 64: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/64.jpg)
64
Pass 1: Find the location LOC of the smallest element in the list A[1], A[2], … A[N]. Then interchange A[LOC] and A[1]. Then: A[1] is sorted
Pass 2: Find the location LOC of the smallest element in the sublist A[2], A[3], … A[N]. Then interchange A[LOC] and A[2]. Then: A[1],A[2] is sorted since A[1] <= A[2].
Pass 3: Find the location LOC of the smallest element in the sublist A[3], A[4], … A[N]. Then interchange A[LOC] and A[3]. Then: A[1], A[2],A[3] is sorted, since A[2] <= A[3].
![Page 65: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/65.jpg)
65
Pass N-1: Find the location LOC of the smallest element in the sublist A[N-1], A[N]. Then interchange A[LOC] and A[N-1]. Then: A[1], A[2], ….. , A[N] is sorted, since A[N-1] <= A[N].
A is sorted after N-1 pass.
![Page 66: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/66.jpg)
66
Selection Sort
Pass A[1]
A[2]
A[3]
A[4]
A[5]
A[6]
A[7]
A[8]K=1
LOC=477 33 44 11 88 22 66 55
K=2 LOC=6
11 33 44 77 88 22 66 55
K=3 LOC=6
11 22 44 77 88 33 66 55
K=4 LOC=6
11 22 33 77 88 44 66 55
K=5 LOC=8
11 22 33 44 88 77 66 55
K=6 LOC=7
11 22 33 44 55 77 66 88
K=7 LOC=4
11 22 33 44 55 66 77 88
Sorted 11 22 33 44 55 66 77 88
![Page 67: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/67.jpg)
67
Complexity
f(n) = (n-1) + (n-2) + …… + 2+ 1 = n(n-1)/2
=O(n2 )
![Page 68: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/68.jpg)
68
Merge SortSuppose the array A containing 8
elements 5, 2, 4, 7, 1, 3, 2, 6
![Page 69: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/69.jpg)
69
5 2 4 7 1 3 2 6
2 5 4 7 1 3
2 6
2 4 5 7 1 2 3 6
1 2 2 4 5 6 7
Merge
Merge
Merge
![Page 70: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/70.jpg)
70
Time complexity = (n log n)
![Page 71: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/71.jpg)
71
Heap Sort
4, 1, 3, 2, 16, 9, 10, 14, 8, 7
![Page 72: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/72.jpg)
72
Heap
16
14
10
8 7
2 4 1
9 3
![Page 73: Lecture 13 data structures and algorithms](https://reader033.fdocuments.us/reader033/viewer/2022061609/554a0b6db4c90507558b46cf/html5/thumbnails/73.jpg)
73
Heap
14
8 10
4 7
2 1
9 3
16
10
8 9
4 7
2
1 3
14 16 i i