![4
i = 0;
while (i < n && a[i] != k)
i++;
return (i < n);
Pseudo-code](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-4-320.jpg)
![5
a[n] = k;
i = 0;
while (a[i] != k)
i++;
return (i < n);
Pseudo-code
sentinel](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-5-320.jpg)
![8
i = 0;
while (i < n && a[i] < k)
i++;
return (i < n && a[i] == k);
Pseudo-code](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-8-320.jpg)
![9
a[n] = k + 1;
i = 0;
while (a[i] < k)
i++;
return (a[i] == k);
Pseudo-code](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-9-320.jpg)
![12
left = 0, right = n – 1;
while (left ≤ right) {
middle = (left + right) / 2;
if (a[middle] == k)
return true;
else
if (k < a[middle])
right = middle – 1;
else
left = middle + 1;
}
return false;
Pseudo-code](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-12-320.jpg)
![14
Searching Algorithms: Case Study
Finding both the smallest and largest values in an array of
size 𝑛 simultaneously
small = large = a[0];
for (i = 1; i < n; i++) {
if (small > a[i]) small = a[i];
if (large < a[i]) large = a[i];
}
small = large = a[0];
for (i = 1; i < n; i++)
if (small > a[i]) small = a[i];
else
if (large < a[i]) large = a[i];](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-14-320.jpg)
![Bubble Sort: Pseudo-code
18
for (i = 1; i < n; i++)
for (j = n - 1; j ≥ i; j--)
if (a[j] < a[j - 1])
swap(a[j], a[j - 1]);](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-18-320.jpg)
![Selec:on Sort: Pseudo-code
21
for (i = 0; i < n – 1; i++) {
minIndex = i;
minValue = a[i];
for (j = i + 1; j < n; j++)
if (a[j] < minValue) {
minIndex = j;
minValue = a[j];
}
a[minIndex] = a[i];
a[i] = minValue;
}](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-21-320.jpg)
![Inser:on Sort: Pseudo-code
25
for (i = 1; i < n; i++) {
v = a[i];
j = i – 1;
while (j ≥ 0 && a[j] > v) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = v;
}
At first, the leE part contains only one element](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-25-320.jpg)
![Interchange Sort: Pseudo-code
28
for (i = 0; i < n – 1; i++)
for (j = i + 1; j < n; j++)
if (a[i] > a[j])
swap(a[i], a[j]);](https://image.slidesharecdn.com/chapter1-introductiontosearchingandsortingalgorithms-student-241111075919-f3164d85/85/Chapter-1-Introduction-to-Searching-and-Sorting-Algorithms-Student-pdf-28-320.jpg)
Chapter 1 - Introduction to Searching and Sorting Algorithms - Student.pdf
- 1. Introduc)on to Searching and Sor)ng Algorithms Chapter 1
- 2. Searching Algorithms • A searching algorithm is a method of loca3ng a specific item in a collec3on of data • For simplicity, let’s assume that our data is an array of 𝑛 posi3ve integers – It may or may not contain duplicate values • Consider two algorithms for searching the contents of an array: – The linear search – The binary search 2
- 3. • The linear search is a very simple algorithm. Some3mes it’s called a sequen&al search • Star3ng with the first element, the algorithm uses a loop to sequen3ally step through a given array • It compares each element with the search key and stops when either – a match is encountered (successful search), or – the end of the array is encountered without finding a match (unsuccessful search) 3 Searching Algorithms: Linear Search
- 4. 4 i = 0; while (i < n && a[i] != k) i++; return (i < n); Pseudo-code
- 5. 5 a[n] = k; i = 0; while (a[i] != k) i++; return (i < n); Pseudo-code sentinel
- 6. • Advantages: – It’s simple, easy to understand and implement – It doesn’t require the data in the array to be stored in any par@cular order • Disadvantage: – It’s inefficient 6 Searching Algorithms: Linear Search
- 7. • How can we improve linear search if a given array is known to be sorted (say, in ascending order)? • Searching in such an array can be stopped as soon as an element greater than or equal to the search key is encountered 7 Searching Algorithms: Linear Search
- 8. 8 i = 0; while (i < n && a[i] < k) i++; return (i < n && a[i] == k); Pseudo-code
- 9. 9 a[n] = k + 1; i = 0; while (a[i] < k) i++; return (a[i] == k); Pseudo-code
- 10. • Given a sorted array, binary search is always our choice • The binary search is a clever algorithm that is much more efficient than the linear search 10 Searching Algorithms: Binary Search
- 11. • It starts with the element in the middle: 𝑎 𝑚 – If 𝑎 𝑚 = 𝑘: 👌 – If 𝑎 𝑚 > 𝑘: the desired value will be found somewhere in the le# half of the array ➡ The right half of the array is eleminated from searching – If 𝑎 𝑚 < 𝑘: the desired value will be found somewhere in the right half of the array ➡ The le# half of the array is eleminated from searching • This process con3nues un3l either the desired value is found or there are no more elements to test 11 Searching Algorithms: Binary Search
- 12. 12 left = 0, right = n – 1; while (left ≤ right) { middle = (left + right) / 2; if (a[middle] == k) return true; else if (k < a[middle]) right = middle – 1; else left = middle + 1; } return false; Pseudo-code
- 13. 13 Searching Algorithms: Binary Search • Advantages: – The binary search is much more efficient than the linear search – How to evaluate the efficiency of the binary search? • Disadvantage: – The input array must be sorted
- 14. 14 Searching Algorithms: Case Study Finding both the smallest and largest values in an array of size 𝑛 simultaneously small = large = a[0]; for (i = 1; i < n; i++) { if (small > a[i]) small = a[i]; if (large < a[i]) large = a[i]; } small = large = a[0]; for (i = 1; i < n; i++) if (small > a[i]) small = a[i]; else if (large < a[i]) large = a[i];
- 15. Sor:ng Algorithms • OOen the data in an array must be sorted in some order • This sec3on will introduce 4 basic sor3ng algorithms: – The bubble sort – The selec@on sort – The inser@on sort – The interchange sort 15
- 16. Sor:ng Algorithms: Bubble Sort • In essence, this algorithm compares adjacent elements of the array and exchanges them if they are out of order 16
- 18. Bubble Sort: Pseudo-code 18 for (i = 1; i < n; i++) for (j = n - 1; j ≥ i; j--) if (a[j] < a[j - 1]) swap(a[j], a[j - 1]);
- 19. Sor:ng Algorithms: Selec:on Sort • The selec3on sort moves elements immediately to their final posi3on in the sorted array 19
- 21. Selec:on Sort: Pseudo-code 21 for (i = 0; i < n – 1; i++) { minIndex = i; minValue = a[i]; for (j = i + 1; j < n; j++) if (a[j] < minValue) { minIndex = j; minValue = a[j]; } a[minIndex] = a[i]; a[i] = minValue; }
- 22. Sor:ng Algorithms: Inser:on Sort • The inser3on sort works in a slightly different way • The given array is split into two parts: – The leE part is always a sorted subarray – The right part is an unsorted subarray • While the right part is not empty, the leO-most element of this part is picked up and inserted back into the leO part such that this sorted subarray is one element larger – How to insert the leE-most element of the right part to the right posi@on in the leE part? 22
- 23. Inser:on Sort: Algorithm • Let the leO-most element of the right part be 𝑣. It will be checked against those in the leO part – If the elements in the leE part are greater than 𝑣, they will be shiEed to the right one posi@on – If an element in the leE part (𝑖) is less than or equal to 𝑣, or (𝑖𝑖) the end of the leE part is reached, 𝑣 can be inserted to the right posi@on • At first, the algorithm assumes that the leO part contains only one element 23
- 25. Inser:on Sort: Pseudo-code 25 for (i = 1; i < n; i++) { v = a[i]; j = i – 1; while (j ≥ 0 && a[j] > v) { a[j + 1] = a[j]; j--; } a[j + 1] = v; } At first, the leE part contains only one element
- 26. Sor:ng Algorithms: Interchange Sort • Similar to the selec3on sort, this algorithm puts the smallest value in the first posi3on, the second smallest value in the next posi3on and so on 26
- 28. Interchange Sort: Pseudo-code 28 for (i = 0; i < n – 1; i++) for (j = i + 1; j < n; j++) if (a[i] > a[j]) swap(a[i], a[j]);
- 29. 29 Basic Sor:ng Algorithms: Conclusions • Advantages – They are simple and easy to implement – They are in-place algorithms, so the space requirement is minimal – They are useful only when sor@ng an array of few elements – The Bubble sort and the Interchange sort are suitable for academic teaching but not for real-life applica@ons – The Selec9on sort tends to minimize data movements – The Inser9on sort can also be useful when input array is almost sorted
- 30. 30 Basic Sor:ng Algorithms: Conclusions • Disadvantage – They do not deal well with an array containing a huge number of elements
- 31. 31 Sor:ng Algorithms: Case Study Develop an efficient in-place algorithm that par33ons an array 𝑎 in even and odd numbers The algorithm must terminate with 𝑎 containing all its even elements preceding all its odd elements In addi3on, even elements are in ascending order and odd elements are in descending order tạo thuật toán : 1 mảng lưu các số số chẵn đứng trước số lẻ số chẵn xếp tăng dần, số lẻ xếp giảm dần
- 32. 32 Sor:ng Algorithms: Case Study Given a two-dimensional array of the size 3×3 containing posi3ve integers Arrange them so that all numbers in each row, in each column and in both diagonals are in ascending order