์ฐ์ ๊ธฐ๋ก ๐ช
[C++ ์๊ณ ๋ฆฌ์ฆ] ํต์ ๋ ฌ ๋ณธ๋ฌธ
[C++ ์๊ณ ๋ฆฌ์ฆ] ํต์ ๋ ฌ
kite707 2024. 11. 26. 21:16ํต์ ๋ ฌ์ ์ซ์ ํ๋(pivot)๋ฅผ ๊ณจ๋ผ์ ์ฌ๋ฐ๋ฅธ ์๋ฆฌ์ ๋ฃ์ด๊ฐ๋ฉฐ ์ ๋ ฌ์ ์งํํ๋ค. ์ด๋ ๋ฐฐ์ด์ ์ชผ๊ฐ๊ฐ๋ฉฐ ์ฌ๊ท์ ์ผ๋ก ์ ๋ ฌ์ ํ๊ธฐ ๋๋ฌธ์ ์ต์ข ์ ์ธ ์๊ฐ ๋ณต์ก๋๋ O(nlogn)์ด๋ค.
๋์ ๊ณผ์
์ด๋ก ์ ์ธ ๋ด์ฉ์ ๋ค์ด๊ฐ๊ธฐ ์์ ์ด๋ค์์ผ๋ก ๋์ํ๋์ง ํ์ธํด๋ณด๋๋ก ํ์. ์๋์ ๊ฐ์ด {5, 4, 1, 7, 6, 2} ๋ฐฐ์ด์ด ์๋ค๊ณ ํ์ ๋ ๋งจ ์ผ์ชฝ์ ํผ๋ด์ผ๋ก ์ก๊ณ left์ right๋ฅผ ์๋์ ๊ฐ์ด ๊ฐ๊ฐ ์ง์ ํ๋ค.
์ฌ๊ธฐ์์ left๋ pivot๋ณด๋ค ์์์ผํ๊ณ , right๋ pivot๋ณด๋ค ์ปค์ผํ๋ค. ์ด์ left๋ฅผ ํ๋์ฉ ์ฎ๊ธฐ๋ฉฐ 5๋ณด๋ค ํฐ ์๊ฐ ์ฒ์์ผ๋ก ๋์ค๋ ์ง์ ์ ์ฐพ์ผ๋ฉด ์๋์ ๊ฐ์ ์ํ๊ฐ ๋๋ค.
right๋ pivot๋ณด๋ค ์ปค์ผํ๋ค๊ณ ํ๋๋ฐ ์ด๋ฏธ pivot๋ณด๋ค ์๋ค. ๊ทธ๋ฌ๋ ์ฌ๊ธฐ์ ๋ฉ์ถฐ์ค๋ค.
์ด์ left์ right๊ฐ ์ญ์ ๋์ง ์์๋ค๋ฉด(left<right) ๋ ์๋ฅผ ๋ฐ๊ฟ์ค๋ค.
์ด์ ๊ณ์ ์์ ๊ฐ์ด left์ right๋ฅผ ์์ง์ฌ์ค๋ค. left๋ 5๋ณด๋ค ํฐ ์๋ฅผ ์ฐพ์ ๋ ๊น์ง, right๋ 5๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์๋ฅผ ์ฐพ์ ๋ ๊น์ง ์์ง์ธ๋ค.
left์ right๊ฐ ์ญ์ ๋์์ผ๋ ๋ ์๋ฅผ ๋ฐ๊พธ์ง ์๋๋ค. ๋ ์๊ฐ ์ญ์ ๋ ์ง๊ธ ์๊ฐ์ ์ ๊ด์ฐฐํ๋ฉด right๋ถํฐ ์ผ์ชฝ์ 5๋ณด๋ค ์์ ์, left๋ถํฐ ์ค๋ฅธ์ชฝ์ 5๋ณด๋ค ํฐ ์๋ผ๋ ๊ฒ์ ์ ์ ์๋ค. ์ฆ 5์ ์ฌ๋ฐ๋ฅธ ์์น๋ right์ left์ฌ์ด์ด๋ค.
์ด์ right์ pivot์ ๋ฐ๊ฟ์ฃผ๋ฉด 5๋ ์ฌ๋ฐ๋ฅธ ์์น์ ๋ค์ด๊ฐ๋ค๊ณ ๋ณด์ฅํ ์ ์๋ค.
์ดํ ์ฌ๊ท์ ์ผ๋ก 5์ ์ผ์ชฝ ๋ฐฐ์ด๊ณผ ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ๋ํด ์ ๋ ฌ์ ์งํํ๋ค. ์ด๋ ๊ฒ ํ๋ํ๋ ์ฌ๋ฐ๋ฅธ ์์น์ ๋ฐฐ์นํด๋๊ฐ๋ ๊ฒ์ด ๋ฐ๋ก ํต์ ๋ ฌ์ด๋ค.
์ฝ๋
์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค. pivot์ ๊ฐ์ฅ ์ผ์ชฝ ์์๋ฅผ ์ ํํ๋๋ก ํ๋ค.
#include <iostream>
#include <vector>
using namespace std;
void swap(vector<int>& arr, int st, int en) {
int tmp = arr[st];
arr[st] = arr[en];
arr[en] = tmp;
}
int parti(vector<int>& arr, int st, int en) {
int pivot = arr[st];
int left = st + 1;
int right = en;
while (left <= right) {
while (left <= en && arr[left] <= pivot)left++;
while (right > st && arr[right] > pivot)right--;
if (left < right)swap(arr, left, right); //์์ 2, 7์ ๋ฐ๊พผ ์ฝ๋
}
swap(arr, right, st); //์์ 5์ 2๋ฅผ ๋ฐ๊พผ ์ฝ๋
return right; //์ ๋ ฌ์ด ์๋ฃ๋ 5์ ์์น ๋ฆฌํด
}
void quickSort(vector<int>& arr, int st, int en) {
if (st >= en)return;
int partition = parti(arr, st, en);
quickSort(arr, st, partition - 1); //์ ๋ ฌ์ด ์๋ฃ๋ 5์ ์ผ์ชฝ ๋ถ๋ถ ์ ๋ ฌ
quickSort(arr, partition + 1, en); //์ ๋ ฌ์ด ์๋ฃ๋ 5์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ์ ๋ ฌ
}
int main() {
vector<int> arr = { 5,4,1,7,6,2 };
quickSort(arr, 0, arr.size() - 1);
for (auto k : arr) {
cout << k << " ";
}
}
ํน์ง
ํต ์ ๋ ฌ์ ์๊ฐ๋ณต์ก๋๋ O(nlogn)์ด๋ค. ๊ทธ๋ฐ๋ฐ ๊ฐ์ O(nlogn)์ธ ๋ค๋ฅธ ์ ๋ ฌ๋ณด๋ค๋ ๋น ๋ฅด๋ค. ์๋ํ๋ฉด ์์ ๋ดค๋ฏ์ด pivot์ ์ฌ๋ฐ๋ฅธ ์์น๋ฅผ ํ์ํ๋ฉฐ ๋ฐฐ์ด์ ์กฐ๊ธ์ฉ ์ ๋ ฌํ๊ณ (2, 7 ์ค์), 5์ ๊ฐ์ด ์์น๊ฐ ํ์ ๋ ์์๋ค์ ์ดํ ์ ๋ ฌ์์ ์ ์ธ๋๊ธฐ ๋๋ฌธ์ด๋ค.
ํ์ง๋ง pivot์ ๊ธฐ์ค์ผ๋ก ์ชผ๊ฐ๋๊ฐ๊ธฐ ๋๋ฌธ์ pivot์ด ๊ณ์ํด์ ๋ฐฐ์ด ๋ด ๊ฐ์ฅ ์์ ๊ฐ์ผ๋ก ์ ์ ๋๋ค๋ฉด O(n^2)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค.
์ค์ต
์ง์ ์ง ํต์ ๋ ฌ ์ฝ๋๋ ์๋ ๋ฌธ์ ๋ฅผ ํตํด ํ ์คํธํ ์ ์๋ค.
https://school.programmers.co.kr/learn/courses/30/lessons/42748
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
ํจ๊ป๋ณด๋ฉด ์ข์ ๊ธ
ํต์ํธ๊ฐ ๋น ๋ฅธ ์ด์ : Locality์ ๊ด์ ์์
https://sdcodebase.tistory.com/34
Locality์ ๊ด์ ์์ Quick sort๊ฐ Merge sort๋ณด๋ค ๋น ๋ฅธ์ด์
Quick sort์ Merge sort๋ nlogn์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ ๋ํ์ ์ธ ์ ๋ ฌ ๋ฐฉ๋ฒ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก Quick sort๊ฐ Merge sort๋ณด๋ค ๋น ๋ฅด๋ค. ๊ทธ ์ด์ ๋ Locality์ ๊ด๋ จ์ด ์๋ค. Locality์ ๊ฐ๋ ์ ์์๋ณด๊ณ ์ Quick sort๊ฐ
sdcodebase.tistory.com
https://gmlwjd9405.github.io/2018/05/10/algorithm-quick-sort.html
[์๊ณ ๋ฆฌ์ฆ] ํต ์ ๋ ฌ(quick sort)์ด๋ - Heee's Development Blog
Step by step goes a long way.
gmlwjd9405.github.io
'Computer Science > ์๋ฃ๊ตฌ์กฐ & ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++ ์๊ณ ๋ฆฌ์ฆ] LCS, Longest Common Subsequence (0) | 2025.02.20 |
---|---|
[C++ ์๊ณ ๋ฆฌ์ฆ] ๋ฌดํฅ๊ทธ๋ํ ์ฌ์ดํด dfs (0) | 2025.01.21 |
[C++] ๋ฒกํฐ ํ์ (0) | 2021.09.07 |
[C++] ์ซ์ ์๋ฆฟ์ ๋ํ๊ธฐ (0) | 2021.09.07 |
[C++ ์๊ณ ๋ฆฌ์ฆ] ๋ถํ ์ ๋ณต(Divide and conquer) (0) | 2021.08.28 |