Sort 알고리즘 구현

CS/Sort/do02reen24/bubbleSort.js

@@ -0,0 +1,12 @@
+function bubbleSort(arr) {
+  for (let i = 0; i < arr.length - 1; i++) {
+    for (let j = 0; j < arr.length - 1 - i; j++) {
+      if (arr[j] > arr[j + 1]) {
+        let temp = arr[j];
+        arr[j] = arr[j + 1];
+        arr[j + 1] = temp;
+      }
+    }
+  }
+  return arr;
+}

CS/Sort/do02reen24/heapSort.js

@@ -0,0 +1,37 @@
+function swap(array, left, right) {
+  const temp = array[left];
+  array[left] = array[right];
+  array[right] = temp;
+}
+
+function heapify(heap) {
+  for (let i = 1; i < heap.length; i++) {
+    let child = i;
+    do {
+      let parent = Math.floor((child - 1) / 2);
+      if (heap[parent] < heap[child]) {
+        swap(heap, parent, child);
+      }
+      child = parent;
+    } while (child !== 0);
+  }
+}
+
+function heapSort(heap) {
+  heapify(heap); // make max heap
+
+  for (let i = heap.length - 1; i > 0; i--) {
+    swap(heap, 0, i);
+    let parent = 0;
+    let child = 1;
+    do {
+      child = 2 * parent + 1;
+      if (heap[child] < heap[child + 1] && child < i - 1) child++;
+      if (heap[parent] < heap[child] && child < i) swap(heap, parent, child);
+      parent = child;
+    } while (child < i);
+  }
+  return heap;
+}
+
+console.log(heapSort([4, 1, 5, 6, 2, 8]));

CS/Sort/do02reen24/insertSort.js

@@ -0,0 +1,12 @@
+function insertSort(arr) {
+  for (let i = 1; i < arr.length; i++) {
+    let index = i;
+    while (arr[index - 1] > arr[index] && index > 0) {
+      let temp = arr[index];
+      arr[index] = arr[index - 1];
+      arr[index - 1] = temp;
+      index--;
+    }
+  }
+  return arr;
+}

CS/Sort/do02reen24/mergeSort.js

@@ -0,0 +1,17 @@
+function merge(left, right) {
+  const result = [];
+  while (left.length && right.length) {
+    if (left[0] <= right[0]) result.push(left.shift());
+    else result.push(right.shift());
+  }
+  return [...result, ...left, ...right];
+}
+
+function mergeSort(arr) {
+  if (arr.length < 2) return arr;
+
+  const mid = Math.floor(arr.length / 2);
+  const left = arr.slice(0, mid);
+  const right = arr.slice(mid, arr.length);
+  return merge(mergeSort(left), mergeSort(right));
+}

CS/Sort/do02reen24/quickSort.js

@@ -0,0 +1,30 @@
+function swap(array, left, right) {
+  const temp = array[left];
+  array[left] = array[right];
+  array[right] = temp;
+}
+
+function divide(array, start, end) {
+  const pivotValue = array[Math.floor((start + end) / 2)];
+
+  while (start <= end) {
+    while (array[start] < pivotValue) start = start + 1;
+    while (array[end] > pivotValue) end = end - 1;
+
+    if (start <= end) {
+      swap(array, start, end);
+      start = start + 1;
+      end = end - 1;
+    }
+  }
+
+  return start;
+}
+
+function quickSort(array, start = 0, end = array.length - 1) {
+  if (start >= end) return;
+  let index = divide(array, start, end);
+  quickSort(array, start, index - 1);
+  quickSort(array, index + 1, end);
+  return array;
+}

CS/Sort/do02reen24/selectSort.js

@@ -0,0 +1,12 @@
+function selectSort(arr) {
+  for (let i = 0; i < arr.length - 1; i++) {
+    let index = i;
+    for (let j = i + 1; j < arr.length; j++) {
+      if (arr[index] > arr[j]) index = j;
+    }
+    let temp = arr[i];
+    arr[i] = arr[index];
+    arr[index] = temp;
+  }
+  return arr;
+}

CS/Sort/do02reen24/sort.md

@@ -0,0 +1,29 @@
+# 📚 Sort
+
+## ⏰ 시간복잡도
+
+|   Name   |   최선   |   평균   |   최악   | 메모리  |
+| :------: | :------: | :------: | :------: | :-----: |
+| 버블정렬 |   O(n)   |  O(n^2)  |  O(n^2)  |  O(1)   |
+| 선택정렬 |  O(n^2)  |  O(n^2)  |  O(n^2)  |  O(1)   |
+| 삽입정렬 |   O(n)   |  O(n^2)  |  O(n^2)  |  O(1)   |
+|  힙정렬  |   O(n)   | O(nlogn) | O(nlogn) |  O(1)   |
+| 병합정렬 | O(nlogn) | O(nlogn) | O(nlogn) |  O(n)   |
+|  퀵정렬  | O(nlogn) | O(nlogn) |  O(n^2)  | O(logn) |
+
+## 🔎 퀵정렬
+
+### 병합 정렬과의 공통점
+
+- Divide and Conquer(분할-정복) 알고리즘에 속함
+- 둘 다 점점 탐색할 배열의 크기를 쪼개서 재귀함수에 넘겨줌
+
+### 병합 정렬과의 차이점
+
+- 병합 정렬과 달리 다른 메모리 공간을 사용하지 않음
+- 병합정렬을 `stable` 하지만, 퀵 정렬을 `unstable`함. (원소들 중 같은 값이 있는 경우 초기 순서가 달라질 수 있기 때문)
+
+### 분할 방법
+
+1. Lomutos' Partition (배열의 맨 마지막 값을 pivot으로 정하는 방식)
+2. Hoare's Parition (물리적으로 배열의 중간값을 pivot으로 정하는 방식)