섹션 2. 정렬(Sorting)

버블 정렬(Bubble sort)

정렬 알고리즘

 

버블(Bubble) : 데이터의 인접 요소끼리 비교하고, swap 연산을 수행하여 정렬

선택(Selection) : 대상에서 가장 크거나 작은 데이터를 찾아가 선택을 반복하면서 정렬

삽입(Insertion) : 대상을 선택해 정렬된 영역에서 선택 데이터의 적절한 위치를 찾아 삽입하면서 정렬

퀵(Quick) : Pivot 값을 선정해 해당 값을 기준으로 정렬

병합(Merge) : 이미 정렬된 부분 집합들을 효율적으로 병합해 전체를 정렬

기수(Radix) : 데이터의 자릿수를 바탕으로 비교해 데이터를 정렬

 

버블 정렬(Bubble sort)은 두 인접한 데이터의 크기를 비교해 정렬하는 방법으로, 간단하게 구현이 가능하다. 시간 복잡도는 O(n^2)으로 다른 정렬 알고리즘보다 느린 편이다.

 

루프를 돌면서 인접한 데이터 간의 swap 연산으로 정렬

 

 

한번 도는데 n번 도는 것을 n번 반복하여 시간 복잡도는 O(n^2) 이며 오른쪽 끝 한자리씩 고정한다.

1. 비교 연산이 필요한 루프 범위 설정
2. 인접한 데이터 값 비교
3. swap 조건에 부합하면 swap 연산을 수행
4. 루프 범위가 끝날 때 까지 2, 3 반복
5. 정렬 영역 설정하여 다음 루프를 실행할때 이 영역 제외
6. 비교 대상이 없어질 때까지 1, 2, 3, 4, 5 반복

만약 특정한 루프의 전체 영역에서 swap이 한 번도 발생하지 않았다면 그 영역 뒤에 있는 데이터가 모두 정렬완료이기 떄문에 프로세스를 종료해도 된다.

 

ex) 버블 정렬 프로그램1 (백준 1377)

1. 문제 분석
   1. 버블 정렬의 swap이 한 번도 일어나지 않은 루프가 언제인지 알아내는 문제
   2. 버블 정렬의 이중 for문에서 안쪽 for문 전체를 돌 때 swap이 일어나지 않았다. 즉 모든 데이터가 정렬됨을 의미, 이 때 프로세스를 바로 종료해 시간 복잡도를 줄일 수 있다.
   3. N의 최대 범위가 500,000이므로 버블 정렬 O(n^2)으로 문제 해결시 시간 초과
   4. 안쪽 for문이 몇번 수행됐는지 구하는 다른 아이디어가 필요
   5. 데이터 정렬 전 index와 정렬 후 index를 비교해 왼쪽으로 가장 많이 이동한 값을 찾아보자
   6. 각 데이터마다 정렬 전 index 값에서 정렬 후 index 값을 빼고 최대값을 찾는다.

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

int main() {
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n;

	cin >> n;

	vector < pair<int, int>> a(n);

	for (int i = 0; i < n; i++) {
		cin >> a[i].first;
		a[i].second = i;
	}

	sort(a.begin(), a.end());

	int max = 0;

	for (int i = 0; i < n; i++) {
		if (max < a[i].second - i) {
			max = a[i].second - i;
		}
	}
	cout << max + 1;
}

 

선택 정렬(Selection sort)

 

선택 정렬은 대상 데이터에서 최대나 최소 데이터를 나열된 순으로 찾아가며 선택하는 방법

선택 정렬은 구현 방법이 복잡하고, 시간 복잡도도 O(n^2)으로 효율적이지 않아 코딩 테스트에서 많이 사용하지 않는다.

 

최소값 또는 최대값을 찾고, 남은 정렬 부분의 가장 앞에 있는 데이터와 swap 하는것이 선택 정렬의 핵심

ex) 오름차순 희망, 최소 값을 찾고 제일 왼쪽과 swap후 앞의 과정 반복

1. 남은 정렬 부분에서 최소 값 또는 최대 값을 찾는다.
2. 남은 정렬 부분에서 가장 앞에 있는 데이터와 선택된 데이터를 swap한다
3. 가장 앞에 있는 데이터의 위치를 변경해(index++) 남은 정렬 부분의 범위를 축소
4. 전체 데이터 크기만큼 index가 커질 때까지, 즉 남은 정렬 부분이 없을 때까지 반복

삽입 정렬(Insertion sort)

삽입 정렬은 이미 정렬된 데이터 범위에 정렬되지 않은 데이터를 적절한 위치에 삽입시켜 정렬하는 방식으로 시간 복잡도는 O(n^2)으로 느린 편이지만 구현하기가 쉽다.

 

선택 데이터를 현재 정렬된 데이터 범위 내에서 적절한 위치에 삽입하는 것이 삽입 정렬의 핵심

 

1. 현재 index에 있는 데이터 값(초록색)을 선택
2. 현재 선택한 데이터가 정렬된 데이터 범위(빨간색)에 삽입될 위치를 탐색
3. 삽입 위치부터 index에 있는 위치까지 shift 연산 수행 (오래걸림)
4. 삽입 위치에 현재 선택한 데이터를 삽입하고 index++ 연산을 수행
5. 전체 데이터의 크기만큼 index가 커질 때까지, 즉 선택할 데이터가 없을때까지 반복

적절한 삽입 위치를 탐색하는 부분에서 이진 탐색(Binary search)등과 같은 탐색 알고리즘을 사용하면 시간 복잡도를 줄일 수 있다.

 

퀵 정렬(Quick sort)

퀵 정렬은 기준값(pivot)을 선정해 해당 값보다 작은 데이터와 큰 데이터로 분류하는 것을 반복해서 정렬하는 알고리즘으로 기준값이 어떻게 선정되는지가 시간 복잡도에 많은 영향을 미침

평균 시간 복잡도는 O(nlogn)이며 최악의 경우 시간 복잡도 O(n^2)이다.

 

pivot을 중심으로 계속 데이터를 2개의 집합으로 나누면서 정렬하는 것이 핵심

 

 

1. 데이터를 분할하는 pivot을 설정 ex) 오른쪽 끝
2. pivot을 기준으로 다음 a ~ e 과정을 거쳐 데이터를 2개의 집합으로 분리
   1. start가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 start를 오른쪽으로 1칸 이동
   2. end가 가리키는 데이터가 pivot이 가리키는 데이터보다 크면 end를 왼쪽으로 1칸 이동
   3. start가 가리키는 데이터가 pivot이 가리키는 데이터보다 크고, end가 가리키는 데이터가 pivot이 가리키는 데이터보다 작으면 start, end가 가리키는 데이터를 swap하고 start는 오른쪽, end는 왼쪽으로 1칸씩 이동
   4. start와 end가 만날 때까지 a, b, c 반복
   5. start와 end가 만나면 만난 지점에서 가리키는 데이터와 pivot이 가리키는 데이터를 비교하여 pivot이 가리키는 데이터가 크면 만난 지점의 오른쪽에, 작으면 만난 지점의 왼쪽에 pivot이 가리키는 데이터를 삽입
3. 분리 집합에서 각각 pivot을 선정
4. 분리 집합이 1개 이하가 될 때까지 1, 2, 3 반복

퀵 정렬의 시간 복잡도는 비교적 준수하기 때문에 코딩 테스트에서 종종 응용, 재귀 함수 형태로 구현 해보는 것을 추천

 

ex) K번째 수 구하기 (백준 11004)

1. 문제 분석
   1. 퀵 정렬은 pivot의 선택에 따라 최악의 시간 복잡도가 O(n^2)이므로 해당 문제에서는 병합 정렬 등을 이용하는게 더 안전하다. 다만 퀵 정렬의 원리를 이해하고자 퀵 정렬로 풀이

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

void Swap(vector<int>& a, int s, int e) {
	int temp = a[s];
	a[s] = a[e];
	a[e] = temp;
}

int Partition(vector<int>& a, int s, int e, int k) {
	if (s + 1 == e) {
		if (a[s] > a[e]) {
			Swap(a, s, e);
			return e;
		}
	}

	int m = (s + e) / 2;
	
	Swap(a, s, m);
	
	int pivot = a[s];
	int i = s + 1;
	int j = e;

	while (i <= j) {
		
		while (pivot < a[j] && j > 0) {
			j--;
		}
		
		while (pivot > a[i] && i < a.size() - 1) {
			i++;
		}

		if (i <= j) {
			Swap(a, i++, j--);
		}
	}
	a[s] = a[j];
	a[j] = pivot;
	return j;
}

void QuickSort(vector<int>& a, int s, int e, int k) {
	int pivot = Partition(a, s, e, k);

	if (pivot == k) {
		return;
	}
	else if (k < pivot) {
		QuickSort(a, s, pivot - 1, k);
	}
	else {
		QuickSort(a, pivot - +1, e, k);
	}
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n, k;

	cin >> n >> k;

	vector<int> a(n, 0);

	for (int i = 0; i < n; i++) {
		cin >> a[i];
	}

	QuickSort(a, 0, n - 1, k - 1);
	cout << a[k - 1];
}

 

병합 정렬(Merge sort)

 

병합 정렬은 분할정복(divide and conquer) 방식을 사용해 데이터를 분할하고 분할한 집합을 정렬하며 합치는 알고리즘.

병합 정렬의 시간 복잡도는 O(nlogn)

 

ex) 최초 7개의 그룹으로 나누고, 4개의 그룹으로 합치고 정렬, 2개의 그룹으로 합치고 정렬

 

병합정렬은 코딩 테스트의 정렬 관련 문제에서 자주 등장, 특히 2개의 그룹을 병합하는 원리는 꼭 숙지하는 것을 추천

2개의 그룹을 병합하는 과정

투 포인터 개념을 사용하여 왼쪽, 오른쪽 그룹을 병합한다. 왼쪽 포인터와 오른쪽 포인터의 값을 비교하여 작은 값을 결과 배열에 추가하고 포인터를 오른쪽으로 1칸 이동

 

기수정렬

기수정렬(radix sort)은 값을 비교하지 않는 특이한 정렬이다. 값을 놓고 비교할 자릿수를 정한 다음 해당 자릿수만 비교한다. 기수정렬의 시간 복잡도는 O(kn)으로, k는 데이터 자릿수이다.

 

기수 정렬은 10개의 큐를 이용한다. 각 큐는 값의 자릿수(0 ~ 9)를 대표한다.

작은 자리 수 부터 비교해야, 10의 자리가 같은 경우 1의 자리 수가 작은 것이 먼저 들어간다.

 

기수 정렬은 시간 복잡도가 가장 짧은 정렬임으로 정렬해야 하는 데이터의 개수가 너무 많으면 기수 정렬 알고리즘을 활요해보는 것을 추천한다.

 

ex) 수 정렬하기3 (백준 10989)

 

1. 문제 분석하기
   1. N의 최대 개수가 10,000,000으로 매우 크기 때문에 O(nlogn)보다 더 빠른 알고리즘이 필요하다.
   2. 문제에서 주어지는 숫자의 크기가 10,000으로 매우 작다
   3. 이러한 특징의 문제는 기수정렬과 계수 정렬(counting sort)를 이용하는 방법이있다.
   4. 계수 정렬의 경우 data를 index로 사용한다.
   5. 계수 정렬의 경우 제약조건이 있다.
      1. 데이터가 양수
      2. 데이터 값이 매우 작아야함

#include<iostream>

using namespace std;

int count_array[10001] = { 0 };

int main() {
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n;

	cin >> n;

	int number = 0;

	for (int i = 1; i <= n; i++) {
		cin >> number;
		count_array[number]++;
	}

	for (int i = 1; i <= 10000; i++) {
		if (count_array[i] != 0) {
			for (int j = 0; j < count_array[i]; j++) {
				cout << i << "\\n";
			}
		}
	}
}