Class5_ADT_Array_Sorting_Rank-Buble-Complexity_12Jan2023.ppt

ee23bt028 6 views 98 slides Oct 02, 2024
Slide 1
Slide 1 of 98
Slide 1
1
Slide 2
2
Slide 3
3
Slide 4
4
Slide 5
5
Slide 6
6
Slide 7
7
Slide 8
8
Slide 9
9
Slide 10
10
Slide 11
11
Slide 12
12
Slide 13
13
Slide 14
14
Slide 15
15
Slide 16
16
Slide 17
17
Slide 18
18
Slide 19
19
Slide 20
20
Slide 21
21
Slide 22
22
Slide 23
23
Slide 24
24
Slide 25
25
Slide 26
26
Slide 27
27
Slide 28
28
Slide 29
29
Slide 30
30
Slide 31
31
Slide 32
32
Slide 33
33
Slide 34
34
Slide 35
35
Slide 36
36
Slide 37
37
Slide 38
38
Slide 39
39
Slide 40
40
Slide 41
41
Slide 42
42
Slide 43
43
Slide 44
44
Slide 45
45
Slide 46
46
Slide 47
47
Slide 48
48
Slide 49
49
Slide 50
50
Slide 51
51
Slide 52
52
Slide 53
53
Slide 54
54
Slide 55
55
Slide 56
56
Slide 57
57
Slide 58
58
Slide 59
59
Slide 60
60
Slide 61
61
Slide 62
62
Slide 63
63
Slide 64
64
Slide 65
65
Slide 66
66
Slide 67
67
Slide 68
68
Slide 69
69
Slide 70
70
Slide 71
71
Slide 72
72
Slide 73
73
Slide 74
74
Slide 75
75
Slide 76
76
Slide 77
77
Slide 78
78
Slide 79
79
Slide 80
80
Slide 81
81
Slide 82
82
Slide 83
83
Slide 84
84
Slide 85
85
Slide 86
86
Slide 87
87
Slide 88
88
Slide 89
89
Slide 90
90
Slide 91
91
Slide 92
92
Slide 93
93
Slide 94
94
Slide 95
95
Slide 96
96
Slide 97
97
Slide 98
98

About This Presentation

very nice and very importat


Slide Content

CS201-Data Structures and
Algorithms
•Text Books:
•T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein,
Introduction to Algorithms, MIT Press, 3/e, 2009.
•Y. Langsam, M. J. Augenstein, and A. M. Tenenbaum, Data
Structures Using C and C++, Prentice Hall, 2/e, 2000.
•S. Sahni, Data Structures, Algorithms, and Applications in C++ ,
Silicon Press, 2/e, 2005.
•Michael T. Goodrich, Roberto Tamassia, and David M., Data
Structures and Algorithms in C++, John Wiley & Sons, Inc., 2/e,
2004

Rank Sort

3
INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
RANK-SORT (A)
1. for j = 1 to n
2. R[j] = 1
// Rank the n elements in A into R
3. for j = 2 to n
4. for i = 1 to j - 1
5. if A[i] <= A[j]
6. R[j] = R[j] + 1
7. else
8. R[i] = R[i] + 1
// Move to correct place in U[1 . . n]
9. for j = 1 to n
10. U[R[j]] = A[j]
// Move the sorted entries into A
11. for j = 1 to n
12. A[j] = U[j]
Rank Sort

INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
RANK-SORT (A)
1. for j = 1 to n
2. R[j] = 1
// Rank the n elements in A into R
3. for j = 2 to n
4. for i = 1 to j - 1
5. if A[i] <= A[j]
6. R[j] = R[j] + 1
7. else
8. R[i] = R[i] + 1
// Move to correct place in U[1 . . n]
9. for j = 1 to n
10. U[R[j]] = A[j]
// Move the sorted entries into A
11. for j = 1 to n
12. A[j] = U[j]
4
5264 1
12345
A
Rank Sort

5
5264 1
12345
A
Rank Sort
11111
5264 1
12345
A
R

6
11111
5264 1
12345
A
R
Rank Sort
2
j

7
11111
5264 1
12345
A
R
Rank Sort
2
jji
5

8
11111
5264 1
12345
A
R
Rank Sort
2
jji
5

9
21111
5264 1
12345
A
R
Rank Sort
2
jji
5

10
21111
5264 1
12345
A
R
Rank Sort
2
ji=j

11
21111
5264 1
12345
A
R
Rank Sort
j
4

12
21111
5264 1
12345
A
R
Rank Sort
j
4
i
5

13
21111
5264 1
12345
A
R
Rank Sort
j
4
i
5

14
31111
5264 1
12345
A
R
Rank Sort
j
4
i
5

15
31111
5264 1
12345
A
R
Rank Sort
j
4
i
2

16
31111
5264 1
12345
A
R
Rank Sort
j
4
i
2

17
31121
5264 1
12345
A
R
Rank Sort
j
4
i
2

18
31121
5264 1
12345
A
R
Rank Sort
i=j
4

19
31121
5264 1
12345
A
R
Rank Sort
j
6

20
31121
5264 1
12345
A
R
Rank Sort
j
6
i
5

21
31121
5264 1
12345
A
R
Rank Sort
j
6
i
5

22
31221
5264 1
12345
A
R
Rank Sort
j
6
i
5

23
31221
5264 1
12345
A
R
Rank Sort
j
6
i
2

24
31221
5264 1
12345
A
R
Rank Sort
j
6
i
2

25
31321
5264 1
12345
A
R
Rank Sort
j
6
i
2

26
31321
5264 1
12345
A
R
Rank Sort
j
6
i
4

27
31321
5264 1
12345
A
R
Rank Sort
j
6
i
4

28
31421
5264 1
12345
A
R
Rank Sort
j
6
i
4

29
31421
5264 1
12345
A
R
Rank Sort
i=j
6

30
31421
5264 1
12345
A
R
Rank Sort
j
1

31
31421
5264 1
12345
A
R
Rank Sort
j
1
i
5

32
31421
5264 1
12345
A
R
Rank Sort
j
1
i
5

33
41421
5264 1
12345
A
R
Rank Sort
j
1
i
5

34
41421
5264 1
12345
A
R
Rank Sort
j
1
i
2

35
41421
5264 1
12345
A
R
Rank Sort
j
1
i
2

36
42421
5264 1
12345
A
R
Rank Sort
j
1
i
2

37
42421
5264 1
12345
A
R
Rank Sort
j
1
i
4

38
42421
5264 1
12345
A
R
Rank Sort
j
1
i
4

39
42431
5264 1
12345
A
R
Rank Sort
j
1
i
4

40
42431
5264 1
12345
A
R
Rank Sort
j
1
i
6

41
42431
5264 1
12345
A
R
Rank Sort
j
1
i
6

42
42531
5264 1
12345
A
R
Rank Sort
j
1
i
6

43
42531
5264 1
12345
A
R
Rank Sort
i=j
1

44
42531
5264 1
12345
A
R
Rank Sort
j
1
6

45
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5

46
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5 2

47
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5 24

48
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5 246

49
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5 2461

50
42531
5264 1
12345
A
R
Rank Sort
j
12345
U 5 2461
A12456

INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
RANK-SORT (A)
1. for j = 1 to n
2. R[j] = 1
// Rank the n elements in A into R
3. for j = 2 to n
4. for i = 1 to j - 1
5. if A[i] <= A[j]
6. R[j] = R[j] + 1
7. else
8. R[i] = R[i] + 1
// Move to correct place in U[1 . . n]
9. for j = 1 to n
10. U[R[j]] = A[j]
// Move the sorted entries into A
11. for j = 1 to n
12. A[j] = U[j]
51
Rank Sort
•Best case:
•Worst case:
•Average case:
2
1 2 3
( )T n bn b n b  
2
1 2 3
( )T n an a n a  
2
1 2 3
( )T n An An A  
a
1
, a
2
and a
2
are constants
b
1
, b
2
and b
3
are constants
A
1
, A
2
and A
3
are constants

INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
RANK-SORT (A)
1. for j = 1 to n
2. R[j] = 1
// Rank the n elements in A into R
3. for j = 2 to n
4. for i = 1 to j - 1
5. if A[i] <= A[j]
6. R[j] = R[j] + 1
7. else
8. R[i] = R[i] + 1
// Move to correct place in U[1 . . n]
9. for j = 1 to n
10. U[R[j]] = A[j]
// Move the sorted entries into A
11. for j = 1 to n
12. A[j] = U[j]
52
Rank Sort

Bubble Sort

54
Bubble Sort
INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
BUBBLE-SORT (A)
// Sort by bubbling the smallest element to current position.
1. j = n
2. while j ≥ 2
// Bubble up the smallest element to its correct position
3. for i = 1 to j - 1
4. if A[i] > A[i + 1]
5. temp = A[i]
6. A[i] = A[i + 1]
7. A[i + 1] = temp
8. j = j - 1

55
Bubble Sort
5264 1
12345
j

56
Bubble Sort
5264 1
12345
j

57
Bubble Sort
5264 1
12345
j
52
ii+1

58
Bubble Sort
5264 1
12345
j
52
ii+1

59
Bubble Sort
5264 1
12345
j
52
ii+1
52

60
Bubble Sort
2564 1
12345
j
54
ii+1

61
Bubble Sort
2564 1
12345
j
54
ii+1

62
Bubble Sort
2564 1
12345
j
54
ii+1
54

63
Bubble Sort
2465 1
12345
j
56
ii+1

64
Bubble Sort
2465 1
12345
j
56
ii+1

65
Bubble Sort
2465 1
12345
j
61
ii+1

66
Bubble Sort
2465 1
12345
j
61
ii+1

67
Bubble Sort
2465 1
12345
j
61
ii+1
61

68
Bubble Sort
2415 1
12345
j
6
i=j

69
Bubble Sort
2415 6
12345
j

70
Bubble Sort
2415 6
12345
j

71
Bubble Sort
2415 6
12345
j
24
ii+1

72
Bubble Sort
2415 6
12345
j
24
ii+1

73
Bubble Sort
2415 6
12345
j
45
ii+1

74
Bubble Sort
2415 6
12345
j
45
ii+1

75
Bubble Sort
2415 6
12345
j
51
ii+1

76
Bubble Sort
2415 6
12345
j
51
ii+1

77
Bubble Sort
2415 6
12345
j
51
ii+1
51

78
Bubble Sort
2411 6
12345
j
5
i=j

79
Bubble Sort
2451 6
12345
j

80
Bubble Sort
2451 6
12345
j

81
Bubble Sort
2451 6
12345
j
24
ii+1

82
Bubble Sort
2451 6
12345
j
24
ii+1

83
Bubble Sort
2451 6
12345
j
41
ii+1

84
Bubble Sort
2451 6
12345
j
41
ii+1

85
Bubble Sort
2451 6
12345
j
41
ii+1
41

86
Bubble Sort
2154 6
12345
j
4
i=j

87
Bubble Sort
2154 6
12345
j

88
Bubble Sort
2154 6
12345
j

89
Bubble Sort
2154 6
12345
j
21
ii+1
)()(
2
nfnT

90
Bubble Sort
2154 6
12345
j
21
ii+1
)()(
2
nfnT

91
Bubble Sort
2154 6
12345
j
21
ii+1
21

92
Bubble Sort
1254 6
12345
j
2
i=j

93
Bubble Sort
1254 6
12345
j

94
Bubble Sort
1254 6
12345
j

95
Bubble Sort
INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
BUBBLE-SORT (A)
// Sort by bubbling the smallest element to current position.
1. j = n
2. while j ≥ 2
// Bubble up the smallest element to its correct position
3. for i = 1 to j - 1
4. if A[i] > A[i + 1]
5. temp = A[i]
6. A[i] = A[i + 1]
7. A[i + 1] = temp
8. j = j - 1
1254 6
12345
j

96
Bubble Sort
INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
BUBBLE-SORT (A)
/* Sort by bubbling the smallest
element to current position. */
1. j = n
2. while j ≥ 2
/* Bubble up the smallest
element to its correct position */
3. for i = 1 to j - 1
4.if A[i] > A[i + 1]
5. temp = A[i]
6. A[i] = A[i + 1]
7. A[i + 1] = temp
8.j = j - 1

97
Bubble Sort
INPUT : A[1..n], array of integers
OUTPUT: Rearrangement of A such that A[1]≤A[2] ≤… ≤A[n]
BUBBLE-SORT (A)
/* Sort by bubbling the smallest
element to current position. */
1. j = n
2. while j ≥ 2
/* Bubble up the smallest
element to its correct position */
3. for i = 1 to j - 1
4.if A[i] > A[i + 1]
5. temp = A[i]
6. A[i] = A[i + 1]
7. A[i + 1] = temp
8.j = j - 1
•Best case:
•Worst case:
•Average case:
2
1 2 3
( )T n bn b n b  
2
1 2 3
( )T n an a n a  
2
1 2 3
( )T n An An A  
a
1
, a
2
and a
2
are constants
b
1
, b
2
and b
3
are constants
A
1
, A
2 and A
3
are constants

Readings
•Read Chapter 1 and 2 in Corman book
•Read Chapter 6 in Tenenbaum book
98