์ ํ ์ ๋ ฌ
๊ฐ๋
max, min ์ ๋ ฌ์ด๋ผ๊ณ ๋ ๋ถ๋ฆฐ๋ค. ์ฒ์๋ถํฐ ๋ ์์๊น์ง ํ์ผ๋ฉด์ ์ต์๋ ์ต๋๋ฅผ ์ฐพ์์ ๋ฆฌ์คํธ์ ์ฒ์์ด๋ ๋์ ๋ฃ๊ณ ํด๋น ์์๋ฅผ ์ ์ธํ ๋ค๋ฅธ ์์์ ๋ํด ๋ค์ ์ ๋ ฌ์ ์ํํ๋ ๋ฐฉ๋ฒ์ด๋ค.
๋ฌด์์๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ์ ์ฒ์๋ถํฐ ๋๊น์ง ํ์ํ ํ, ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฆฌ์คํธ์ ๋ง์ง๋ง ์์์ ๊ตํํ๋ค.
๊ทธ ํ ๋ง์ง๋ง ์์๋ฅผ ์ ์ธํ ์ฑ๋ก ์ฒ์๋ถํฐ ๋๊น์ง ๋ฐ์ดํฐ๋ฅผ ํ์ํ ํ, ๊ฐ์ฅ ํฐ ์๋ฅผ ๋ฆฌ์คํธ์ ๋ง์ง๋ง ์์์ ๊ตํํ๋ค.
๊ตฌํ
์์ฌ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
(min ์ ๋ ฌ)
for i=0 to n:
a[i]๋ถํฐ a[n-1]๊น์ง ์ฐจ๋ก๋ก ๋น๊ตํ์ฌ ์ต์๊ฐ์ด ์๋ a[j]๋ฅผ ์ฐพ๋๋ค.
a[i]์ a[j]๋ฅผ ๋ฐ๊พผ๋ค.
(max ์ ๋ ฌ)
for i=0 to n:
a[0]๋ถํฐ a[n-i-1]๊น์ง ์ฐจ๋ก๋ก ๋น๊ตํ์ฌ ์ต๋๊ฐ์ด ์๋ a[j]๋ฅผ ์ฐพ๋๋ค.
a[n-i-1]๊ณผ a[j]๋ฅผ ๋ฐ๊พผ๋ค.
c++๋ก ๊ตฌํํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
void selectionSort(int* arr) {
cout << "selection sort(min, max sort)" << endl;
for (int i = 0; i < arr_size; i++) {
int max_idx = 0;
for (int j = 0; j < arr_size - i; j++) {
if (arr[max_idx] < arr[j])
max_idx = j; // ์ต๋๊ฐ ์ฐพ๊ธฐ
}
swap(arr, max_idx, arr_size - 1 - i);
// ์ต๋๊ฐ ๋ค๋ก ์ฎ๊ฒจ๋๊ธฐ
}
}
์๊ฐ ๋ณต์ก๋
์ ํ ์ ๋ ฌ์ ๋ฆฌ์คํธ์ ์ฌ์ด์ฆ๊ฐ ๋ค์ด๊ฐ ๋ฐ๋ณต๋ฌธ์ด 2๊ฐ๋ ์์ผ๋ฏ๋ก O(n^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค. ์ต์ , ์ต์ , ํ๊ท ์๊ฐ๋ณต์ก๋๊ฐ O(n^2)์ผ๋ก ๊ฐ๋ค.
์ ํํ๋ ๋น๊ต ํ์๊ฐ n(n-1)/2
๋ฒ์ผ๋ก O(n^2)
์ด๊ณ ์ด๋ ํ์๊ฐ ์ต๋3(n-1)
์ด๋ฏ๋ก ์ ์ฒด ๋ณต์ก๋๊ฐ O(n^2)
์ด๋ค.
ํน์ง
- ๋ถ์์ ์ ๋ ฌ์ด๋ค.
- ex) 5345268 => 5์ ์์น๊ฐ ๋ค๋ฐ๋๋ค.
๋ฒ๋ธ ์ ๋ ฌ
๊ฐ๋
๋ฒ๋ธ ์ ๋ ฌ์ ์์์๋ถํฐ ๊ฑฐํ์ด ํ๋ฏ์ด ํ๊ฒจ์ ํฐ ์๋ฅผ ๋ค๋ก ๋ณด๋ด๋ ์ ๋ ฌ์ด๋ค.
๋ฌด์์๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ ์ฒ์๋ถํฐ ๋ ์์์ฉ ์ง์ ์ง์ด์ ๋์๋ฅผ ๋น๊ตํ๋ค.
์์ ๋ฐฐ์น๋ ์๊ฐ ๋ค์ ์๋ณด๋ค ํฌ๋ฉด ์๋ฆฌ๋ฅผ ๋ฐ๊พผ๋ค. ํฐ ์๊ฐ ๋ค๋ก ๊ฐ๊ฒ ๋ง๋๋ ๊ฒ์ด๋ค.
์ด๋ ๊ฒ ๋ฐ๋ณตํ๋ค๋ณด๋ฉด ๋ฆฌ์คํธ์์ ๊ฐ์ฅ ํฐ ์์ธ 9๊ฐ ๋งจ ๋ค๋ก ๋ฐ๋ ค๋๊ฒ ๋๋ค.
๊ทธ ํ์๋ 9๋ฅผ ์ ์ธํ๊ณ ๋จ์ ์์์ ํํด์ ๋ค์ ์ฒ์๋ถํฐ ๋น๊ตํ๋ค.
๊ตฌํ
์์ฌ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
for i=0 to n:
for j=0 to n-i:
arr[i]์ arr[i+1]์ ๋น๊ตํ๋ค. arr[i]๊ฐ ๋ ํฌ๋ฉด ๋ ์๋ฅผ ๊ตํํ๋ค.
c++๋ก ๊ตฌํํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
void swap(int* arr, int idx1, int idx2) {
int tmp = arr[idx1];
arr[idx1] = arr[idx2];
arr[idx2] = tmp;
}
void bubbleSort(int* arr) {
cout << "bubble sort" << endl;
for (int i = 0; i < arr_size-1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1); // ์ด์ํ ๋ ๊ฐ์ ์์ ๋น๊ต
}
}
}
}
์๊ฐ ๋ณต์ก๋
๋ฒ๋ธ ์ ๋ ฌ์ ๋ฆฌ์คํธ์ ์ฌ์ด์ฆ๊ฐ ๋ค์ด๊ฐ ๋ฐ๋ณต๋ฌธ์ด 2๊ฐ๋ ์์ผ๋ฏ๋ก O(n^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ๋๋ค. ์ต์ , ์ต์ , ํ๊ท ์๊ฐ๋ณต์ก๋๊ฐ O(n^2)์ผ๋ก ๊ฐ๋ค.
์ ํํ๋ ๋น๊ต ํ์๊ฐn(n-1)/2 ๋ฒ
์ผ๋ก O(n^2)
์ด๊ณ ์ด๋ ํ์๊ฐ ์ต๋ O(n^2)
์ด๋ฏ๋ก ์ ์ฒด ๋ณต์ก๋๊ฐ O(n^2)
์ด๋ค.
ํน์ง
- ์์ ์ ๋ ฌ์ด๋ค.
์ฝ์ ์ ๋ ฌ
๊ฐ๋
์ฝ์ ์ ๋ ฌ์ ์ ๋ ฌ๋ ์์๋ค๊ณผ ํ์ฌ ์์๋ฅผ ๋น๊ตํ์ฌ ์์ ์ ์์น๋ฅผ ์ฐพ์ ์ฝ์ ํ๋ ์ ๋ ฌ์ด๋ค.
๋ฌด์์๋ก ์ ๋ ฌ๋ ๋ฐ์ดํฐ์ ์ฒซ๋ฒ์งธ ์์๋ ์ด๋ฏธ ์ ๋ ฌ๋ ์์๋ก ๋ณธ๋ค.
์ ๋ ฌํ ์์๋ฅผ ์ด๋ฏธ ์ ๋ ฌ๋ ์์์ ๋น๊ตํ์ฌ ๋ง๋ ์์น์ ์ฝ์ ํ๋ค.
์ ๋ ฌ๋์ง ์์ ์์๋ฅผ ๋ง๋ ์์น๋ฅผ ์ฐพ์ ์ฝ์ ํ๋ ์์ผ๋ก ์ ๋ ฌ๋ ์์๋ก ๋ง๋๋ ์์ ์ ๋ฐ๋ณตํ๋ค๋ณด๋ฉด ์ ์ฒด ์์๊ฐ ์ ๋ ฌ๋๋ค.
๊ตฌํ
์์ฌ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
for i=1 to n:
for j=i-1 to 0:
arr[j]๊ฐ arr[i]๋ณด๋ค ์๋ค๋ฉด j+1์ ์์น์ arr[i]๋ฅผ ์ฝ์
ํ๋ค.
c++๋ก ๊ตฌํํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
void insert(int* arr, int idx, int data_idx) {
if (idx == data_idx)
return;
int tmp = arr[data_idx];
for (int i = data_idx-1; i >= idx; i--) {
arr[i + 1] = arr[i];
}
arr[idx] = tmp;
}
void insertionSort(int* arr) {
cout << "insertion sort" << endl;
for (int i = 1; i < arr_size; i++) { // ์ ๋ ฌ๋์ง ์์ ์์
int idx = i;
for (int j = i-1; j >= 0; j--) { // ์ ๋ ฌ๋ ์์
if (arr[j] > arr[i]) {
idx = j;
}
else
break;
}
insert(arr, idx, i);
}
}
์๊ฐ ๋ณต์ก๋
์ฝ์
์ ๋ ฌ์ ์ญ์ ์ ๋ ฌ๋์ด์๋ ์ต์
์ ๊ฒฝ์ฐ (1+2+...+n-1)๋ฒ ๋น๊ต๋ฅผ ์ํํ๋ค. ์ด๋๋ ๋น๊ต์ ๊ฐ์ด ๋ฐ์ํ๋ฏ๋ก ์๊ฐ๋ณต์ก๋๋ n(n-1)/2
์ฆ O(n^2)
์ด๋ค.
์ต์ ์ ์ด๋ฏธ ์ ๋ ฌ๋์ด์๋ ๊ฒฝ์ฐ์ด๋ฉฐ, ๋๋ฒ์งธ ๋ฐ๋ณต๋ฌธ์ด ํญ์ 1๋ฒ์ฉ๋ง ์คํ๋๋ฏ๋ก ๋น๊ตํ์๋ n-1 ๋ฒ
์ด๋ฉฐ ์ด๋ํ์๋ 0๋ฒ
์ด๋ฏ๋ก O(n)
์ด๋ค.
ํน์ง
- ์์ ์ ๋ ฌ์ด๋ค.
'์ปดํจํฐ๊ณผํ (CS) > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] ์๊ณ ๋ฆฌ์ฆ ๊ฐ๋ ๊ณต๋ถ :: ํ์ - BST (0) | 2020.08.30 |
---|---|
[c++] ์๊ณ ๋ฆฌ์ฆ ๊ฐ๋ ๊ณต๋ถ :: ์ ๋ ฌ (ํต ์ ๋ ฌ, ํฉ๋ณ ์ ๋ ฌ) (0) | 2020.08.25 |
[c++] ์๊ณ ๋ฆฌ์ฆ ๊ฐ๋ ๊ณต๋ถ :: ์ ๋ ฌ (๊ฐ์) (0) | 2020.08.16 |
[c++] ์๊ณ ๋ฆฌ์ฆ ๊ฐ๋ ๊ณต๋ถ :: ์ฌ๊ทํธ์ถ (๋์ ๊ณํ๋ฒ) (1) | 2020.08.09 |
[c++] ์๊ณ ๋ฆฌ์ฆ ๊ฐ๋ ๊ณต๋ถ :: ์ฌ๊ทํธ์ถ (์์ ํ์) (0) | 2020.07.31 |
Comment