first commit

Author: gyusuk

Algorithm/HeapSort.md

@@ -0,0 +1,186 @@
+#### 힙 소트(Heap Sort)
+
+---
+
+
+
+완전 이진 트리를 기본으로 하는 힙(Heap) 자료구조를 기반으로한 정렬 방식
+
+***완전 이진 트리란?***
+
+> 삽입할 때 왼쪽부터 차례대로 추가하는 이진 트리
+
+
+
+힙 소트는 `불안정 정렬`에 속함
+
+
+
+**시간복잡도**
+
+|   평균   |   최선   |   최악   |
+| :------: | :------: | :------: |
+| O(nlogn) | O(nlogn) | O(nlogn) |
+
+
+
+##### 과정
+
+1. 최대 힙을 구성
+2. 현재 힙 루트는 가장 큰 값이 존재함. 루트의 값을 마지막 요소와 바꾼 후, 힙의 사이즈 하나 줄임
+3. 힙의 사이즈가 1보다 크면 위 과정 반복
+
+
+
+<img src="https://t1.daumcdn.net/cfile/tistory/999896445AD4953023">
+
+루트를 마지막 노드로 대체 (11 → 4), 다시 최대 힙 구성
+
+<img src="https://t1.daumcdn.net/cfile/tistory/99E1AD445AD4953015">
+
+
+
+이와 같은 방식으로 최대 값을 하나씩 뽑아내면서 정렬하는 것이 힙 소트
+
+
+
+```
+public void heapSort(int[] array) {
+    int n = array.length;
+    
+    // max heap 초기화
+    for (int i = n/2-1; i>=0; i--){
+        heapify(array, n, i); // 1
+    }
+    
+    // extract 연산
+    for (int i = n-1; i>0; i--) {
+        swap(array, 0, i); 
+        heapify(array, i, 0); // 2
+    }
+}
+```
+
+
+
+##### 1번째 heapify
+
+> 일반 배열을 힙으로 구성하는 역할
+>
+> 자식노드로부터 부모노드 비교
+>
+> 
+>
+> - *n/2-1부터 0까지 인덱스가 도는 이유는?*
+>
+>   부모 노드의 인덱스를 기준으로 왼쪽 자식노드 (i*2 + 1), 오른쪽 자식 노드(i*2 + 2)이기 때문
+
+
+
+##### 2번째 heapify
+
+> 요소가 하나 제거된 이후에 다시 최대 힙을 구성하기 위함
+>
+> 루트를 기준으로 진행(extract 연산 처리를 위해)
+
+
+
+```
+public void heapify(int array[], int n, int i) {
+    int p = i;
+    int l = i*2 + 1;
+    int r = i*2 + 2;
+    
+    //왼쪽 자식노드
+    if (l < n && array[p] < array[l]) {
+        p = l;
+    }
+    //오른쪽 자식노드
+    if (r < n && array[p] < array[r]) {
+        p = r;
+    }
+    
+    //부모노드 < 자식노드
+    if(i != p) {
+        swap(array, p, i);
+        heapify(array, n, p);
+    }
+}
+```
+
+**다시 최대 힙을 구성할 때까지** 부모 노드와 자식 노드를 swap하며 재귀 진행
+
+
+
+퀵정렬과 합병정렬의 성능이 좋기 때문에 힙 정렬의 사용빈도가 높지는 않음.
+
+하지만 힙 자료구조가 많이 활용되고 있으며, 이때 함께 따라오는 개념이 `힙 소트`
+
+
+
+##### 힙 소트가 유용할 때
+
+- 가장 크거나 가장 작은 값을 구할 때
+
+  > 최소 힙 or 최대 힙의 루트 값이기 때문에 한번의 힙 구성을 통해 구하는 것이 가능
+
+- 최대 k 만큼 떨어진 요소들을 정렬할 때
+
+  > 삽입정렬보다 더욱 개선된 결과를 얻어낼 수 있음
+
+
+
+##### 전체 소스 코드
+
+```
+private void solve() {
+    int[] array = { 230, 10, 60, 550, 40, 220, 20 };
+ 
+    heapSort(array);
+ 
+    for (int v : array) {
+        System.out.println(v);
+    }
+}
+ 
+public static void heapify(int array[], int n, int i) {
+    int p = i;
+    int l = i * 2 + 1;
+    int r = i * 2 + 2;
+ 
+    if (l < n && array[p] < array[l]) {
+        p = l;
+    }
+ 
+    if (r < n && array[p] < array[r]) {
+        p = r;
+    }
+ 
+    if (i != p) {
+        swap(array, p, i);
+        heapify(array, n, p);
+    }
+}
+ 
+public static void heapSort(int[] array) {
+    int n = array.length;
+ 
+    // init, max heap
+    for (int i = n / 2 - 1; i >= 0; i--) {
+        heapify(array, n, i);
+    }
+ 
+    // for extract max element from heap
+    for (int i = n - 1; i > 0; i--) {
+        swap(array, 0, i);
+        heapify(array, i, 0);
+    }
+}
+ 
+public static void swap(int[] array, int a, int b) {
+    int temp = array[a];
+    array[a] = array[b];
+    array[b] = temp;
+}
+```
+

Algorithm/MergeSort.md

@@ -0,0 +1,165 @@
+#### 머지 소트(Merge Sort)
+
+---
+
+
+
+합병 정렬이라고도 부르며, 분할 정복 방법을 통해 구현
+
+***분할 정복이란?***
+
+> 큰 문제를 작은 문제 단위로 쪼개면서 해결해나가는 방식
+
+
+
+빠른 정렬로 분류되며, 퀵소트와 함께 많이 언급되는 정렬 방식이다.
+
+
+
+퀵소트와는 반대로 `안정 정렬`에 속함
+
+**시간복잡도**
+
+|   평균   |   최선   |   최악   |
+| :------: | :------: | :------: |
+| O(nlogn) | O(nlogn) | O(nlogn) |
+
+요소를 쪼갠 후, 다시 합병시키면서 정렬해나가는 방식으로, 쪼개는 방식은 퀵정렬과 유사
+
+
+
+- mergeSort
+
+```
+public void mergeSort(int[] array, int left, int right) {
+    
+    if(left < right) {
+        int mid = (left + right) / 2;
+        
+        mergeSort(array, left, mid);
+        mergeSort(array, mid+1, right);
+        merge(array, left, mid, right);
+    }
+    
+}
+```
+
+정렬 로직에 있어서 merge() 메소드가 핵심
+
+
+
+*퀵소트와의 차이점*
+
+> 퀵정렬 : 우선 피벗을 통해 정렬(partition) → 영역을 쪼갬(quickSort)
+>
+> 합병정렬 : 영역을 쪼갤 수 있을 만큼 쪼갬(mergeSort) →  정렬(merge)
+
+
+
+- merge()
+
+```
+public static void merge(int[] array, int left, int mid, int right) {
+    int[] L = Arrays.copyOfRange(array, left, mid + 1);
+    int[] R = Arrays.copyOfRange(array, mid + 1, right + 1);
+    
+    int i = 0, j = 0, k = left;
+    int ll = L.length, rl = R.length;
+    
+    while(i < ll && j < rl) {
+        if(L[i] <= R[j]) {
+            array[k] = L[i++];
+        }
+        else {
+            array[k] = R[j++];
+        }
+        k++;
+    }
+    
+    // remain
+    while(i < ll) {
+        array[k++] = L[i++];
+    }
+    while(j < rl) {
+        array[k++] = R[j++];
+    }
+}
+```
+
+이미 **합병의 대상이 되는 두 영역이 각 영역에 대해서 정렬이 되어있기 때문**에 단순히 두 배열을 **순차적으로 비교하면서 정렬할 수가 있다.**
+
+
+
+
+
+**★★★합병정렬은 순차적**인 비교로 정렬을 진행하므로, **LinkedList의 정렬이 필요할 때 사용하면 효율적**이다.★★★
+
+
+
+*LinkedList를 퀵정렬을 사용해 정렬하면?*
+
+> 성능이 좋지 않음
+>
+> 퀵정렬은, 순차 접근이 아닌 **임의 접근이기 때문**
+
+
+
+**LinkedList는 삽입, 삭제 연산에서 유용**하지만 **접근 연산에서는 비효율적**임
+
+따라서 임의로 접근하는 퀵소트를 활용하면 오버헤드 발생이 증가하게 됨
+
+> 배열은 인덱스를 이용해서 접근이 가능하지만, LinkedList는 Head부터 탐색해야 함
+>
+> 배열[O(1)] vs LinkedList[O(n)] 
+
+
+
+
+
+```
+private void solve() {
+    int[] array = { 230, 10, 60, 550, 40, 220, 20 };
+ 
+    mergeSort(array, 0, array.length - 1);
+ 
+    for (int v : array) {
+        System.out.println(v);
+    }
+}
+ 
+public static void mergeSort(int[] array, int left, int right) {
+    if (left < right) {
+        int mid = (left + right) / 2;
+ 
+        mergeSort(array, left, mid);
+        mergeSort(array, mid + 1, right);
+        merge(array, left, mid, right);
+    }
+}
+ 
+public static void merge(int[] array, int left, int mid, int right) {
+    int[] L = Arrays.copyOfRange(array, left, mid + 1);
+    int[] R = Arrays.copyOfRange(array, mid + 1, right + 1);
+ 
+    int i = 0, j = 0, k = left;
+    int ll = L.length, rl = R.length;
+ 
+    while (i < ll && j < rl) {
+        if (L[i] <= R[j]) {
+            array[k] = L[i++];
+        } else {
+            array[k] = R[j++];
+        }
+        k++;
+    }
+ 
+    while (i < ll) {
+        array[k++] = L[i++];
+    }
+ 
+    while (j < rl) {
+        array[k++] = R[j++];
+    }
+}
+```
+