Quick Sort, Bubble Sort

Author: ChauDinh

Sorting/BubleSort.js

@@ -0,0 +1,15 @@
+var BubbleSort = function (array) {
+    if (array.length === 0 || array.length === 1)
+        return array;
+    for (var i = 0; i < array.length - 1; i++) {
+        for (var j = array.length - 1; j >= i + 1; j--) {
+            if (array[j - 1] > array[j]) {
+                var tmp = array[j];
+                array[j] = array[j - 1];
+                array[j - 1] = tmp;
+            }
+        }
+    }
+    return array;
+};
+console.log(BubbleSort([1, 2, -4, 3, 0, 20, 15]));

Sorting/BubleSort.ts

@@ -0,0 +1,15 @@
+const BubbleSort = (array: number[]) => {
+  if (array.length === 0 || array.length === 1) return array;
+  for (let i = 0; i < array.length - 1; i++) {
+    for (let j = array.length - 1; j >= i + 1; j--) {
+      if (array[j - 1] > array[j]) {
+        let tmp = array[j];
+        array[j] = array[j - 1];
+        array[j - 1] = tmp;
+      }
+    }
+  }
+  return array;
+};
+
+console.log(BubbleSort([1, 2, -4, 3, 0, 20, 15]));

Sorting/QuickSort.js

@@ -0,0 +1,30 @@
+var QuickSort = function (L, H, array) {
+    var _a;
+    if (array.length === 0 || array.length === 1)
+        return array;
+    var i = L;
+    var j = H;
+    var mid = array[L + Math.floor((H - L) / 2)];
+    do {
+        while (array[i] < mid) {
+            i++;
+        }
+        while (array[j] > mid) {
+            j--;
+        }
+        if (i <= j) {
+            _a = [array[j], array[i]], array[i] = _a[0], array[j] = _a[1];
+            i++;
+            j--;
+        }
+    } while (i <= j);
+    if (L < j) {
+        QuickSort(L, j, array);
+    }
+    if (i < H) {
+        QuickSort(i, H, array);
+    }
+    return array;
+};
+var arr = [1, 2, -4, 3, 0, 20, 15];
+console.log(QuickSort(0, arr.length - 1, arr));

Sorting/QuickSort.ts

@@ -0,0 +1,33 @@
+const QuickSort = (L, H: number, array: number[]) => {
+	if (array.length === 0 || array.length === 1) return array;
+	let i: number = L;
+	let j: number = H;
+	let mid: number = array[L + Math.floor((H - L) / 2)];
+	do {
+		while (array[i] < mid) {
+			i++;
+		}
+
+		while (array[j] > mid) {
+			j--;
+		}
+
+		if (i <= j) {
+			[array[i], array[j]] = [array[j], array[i]];
+			i++;
+			j--;
+		}
+	} while (i <= j);
+
+	if (L < j) {
+		QuickSort(L, j, array);
+	}
+	if (i < H) {
+		QuickSort(i, H, array);
+	}
+
+	return array;
+};
+
+const arr: number[] = [1, 2, -4, 3, 0, 20, 15];
+console.log(QuickSort(0, arr.length - 1, arr));

Sorting/README.md

@@ -0,0 +1,41 @@
+# Sorting (Vietnamese)
+
+Sắp xếp là một lĩnh vực quan trọng trong lập trình, hầu hết các ngôn ngữ lập
+trình đều có sẵn các hàm phục vụ cho việc tìm kiếm, sắp xếp. Theo Donald. Knuth
+thì 40% lượng công việc tính toán của máy tính là dành cho sắp xếp. Trong các
+thuật toán sắp xêp hiện nay thì Quick Sort là thuật toán cho độ phức tạp về thời
+gian (Time Complexity) trung bình tốt nhất, chúng ta sẽ bàn kỹ hơn ở bài tổng
+kết.
+
+Một lưu ý là dữ liệu của chúng ta có thể được nằm ở nhiều nơi trong một hệ thống
+hoàn chỉnh, có thể ở database, ở localStorage trong trình duyệt, ở redis cache,
+... nên việc sắp xếp có thể cần thêm một số bước chuẩn hóa, làm sạch dữ liệu...
+nhưng ở đây ta chỉ nói đến trường hợp toàn bộ dữ liệu cần sắp xếp là cùng kiểu và phải được đưa
+vào bộ nhớ chính.
+
+## I. Bài toán
+
+Cho mảng A bao gồm N phần tử cần được sắp xếp a[1], a[2], ..., a[n]. Khi đó, ta
+có thể sắp xếp mảng A lại theo thứ tự tăng dần:
+
+a[1] <= a[2] <= ... <= a[n]
+
+Hoặc theo thứ tự giảm dần:
+
+a[1] >= a[2] >= ... >= a[n]
+
+Do đặc điểm của mảng là cho phép ta duyệt từ trái (left) sang phải hoặc từ phải
+(right) sang trái nên bài toán sắp xếp tăng dần có thể xem là tương đương với
+bài toán sắp xếp giảm dần, chỉ ngược về vị trí ban đầu của phép duyệt.
+
+Trong bài giảng này, ta sẽ tìm hiểu lần lượt các ý tưởng sắp xếp cũng như cài
+đặt tất cả các thuật toán sắp xếp. Mặc dù các hàm sắp xếp của chúng ta có vẻ thừa thãi, việc cài đặt lại các
+thuật toán này giúp chúng ta hiểu rõ hơn về mặt ý tưởng cũng như các kỹ thuật
+cài đặt quan trọng như đệ quy, đánh dấu, dãy tạm, chia để trị, ...
+
+## II. Sắp xếp nổi bọt (Buble Sort)
+
+<i>Bài toán tìm phần tử nhỏ (lớn) thứ K của mảng:</i> Cho một mảng A gồm N phần
+tử, tìm phần tử nhỏ thứ K (K <= N) của mảng đó.
+
+Ý tưởng của bài này khá đơn giản, nhưng nó cung cấp cho chúng ta một