更新算法

Algorithm/BubbleSort.h

@@ -1,15 +1,27 @@
+/*
+
+选择排序思路：
+1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
+2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
+3. 针对所有的元素重复以上的步骤，除了最后一个。
+4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
+
+*/
+
 // 冒泡排序
 void BubbleSort(vector<int>& v) {
-	if (v.size() <= 0)
+	int len = v.size();
-		return;
+	for (int i = 0; i < len - 1; ++i)
-	int temp;
+		for (int j = 0; j < len - 1 - i; ++j)
-	for (int i = 0; i < v.size() - 1; ++i) {
+			if (v[j] > v[j + 1]) 
-		for (int j = 0; j < v.size() - 1 - i; ++j) {
+				swap(v[j], v[j + 1]);
-			if (v[j] > v[j + 1]) {  // 从小到大
+}
-				temp = v[j];
+
-				v[j] = v[j + 1];
+// 模板实现冒泡排序
-				v[j + 1] = temp;
+template<typename T> //整數或浮點數皆可使用,若要使用物件(class)時必須設定大於(>)的運算子功能
-			}
+void bubble_sort(T arr[], int len) {
-		}
+	for (int i = 0; i < len - 1; i++)
-	}
+		for (int j = 0; j < len - 1 - i; j++)
+			if (arr[j] > arr[j + 1])
+				swap(arr[j], arr[j + 1]);
 }

Algorithm/BubbleSort_orderly.h

@@ -1,17 +1,13 @@
 // 冒泡排序（改进版）
 void BubbleSort_orderly(vector<int>& v) {
-	if (v.size() <= 0)
+	int len = v.size();
-		return;
-	int temp;
 	bool orderly = false;
-	for (int i = 0; i < v.size() - 1 && !orderly; ++i) {
+	for (int i = 0; i < len - 1 && !orderly; ++i) {
 		orderly = true;
-		for (int j = 0; j < v.size() - 1 - i; ++j) {
+		for (int j = 0; j < len - 1 - i; ++j) {
 			if (v[j] > v[j + 1]) {  // 从小到大
 				orderly = false;	// 发生交换则仍非有序
-				temp = v[j];
+				swap(v[j], v[j + 1]);
-				v[j] = v[j + 1];
-				v[j + 1] = temp;
 			}
 		}
 	}

Algorithm/QuickSort.h

@@ -1,4 +1,15 @@
-// 快速排序
+/*
+
+快速排序思路：
+1. 选取第一个数为基准
+2. 将比基准小的数交换到前面，比基准大的数交换到后面
+3. 对左右区间重复第二步，直到各区间只有一个数
+
+*/
+
+// ----------------------------------------------------
+
+// 快速排序（递归）
 void QuickSort(vector<int>& v, int low, int high) {
 	if (low >= high)		// 结束标志
 		return;
@@ -26,4 +37,69 @@ void QuickSort(vector<int>& v, int low, int high) {
 	QuickSort(v, low, first - 1);
 	// 后半递归
 	QuickSort(v, first + 1, high);
+}
+
+// ----------------------------------------------------
+
+// 模板实现快速排序（递归）
+template <typename T>
+void quick_sort_recursive(T arr[], int start, int end) {
+    if (start >= end)
+        return;
+    T mid = arr[end];
+    int left = start, right = end - 1;
+    while (left < right) {
+        while (arr[left] < mid && left < right)
+            left++;
+        while (arr[right] >= mid && left < right)
+            right--;
+        std::swap(arr[left], arr[right]);
+    }
+    if (arr[left] >= arr[end])
+        std::swap(arr[left], arr[end]);
+    else
+        left++;
+    quick_sort_recursive(arr, start, left - 1);
+    quick_sort_recursive(arr, left + 1, end);
+}
+template <typename T> //整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)、"大於"(>)、"不小於"(>=)的運算子功能
+void quick_sort(T arr[], int len) {
+    quick_sort_recursive(arr, 0, len - 1);
+}
+
+// ----------------------------------------------------
+
+// 模板实现快速排序（迭代）
+struct Range {
+    int start, end;
+    Range(int s = 0, int e = 0) {
+        start = s, end = e;
+    }
+};
+template <typename T> // 整數或浮點數皆可使用,若要使用物件(class)時必須設定"小於"(<)、"大於"(>)、"不小於"(>=)的運算子功能
+void quick_sort(T arr[], const int len) {
+    if (len <= 0)
+        return; // 避免len等於負值時宣告堆疊陣列當機
+    // r[]模擬堆疊,p為數量,r[p++]為push,r[--p]為pop且取得元素
+    Range r[len];
+    int p = 0;
+    r[p++] = Range(0, len - 1);
+    while (p) {
+        Range range = r[--p];
+        if (range.start >= range.end)
+            continue;
+        T mid = arr[range.end];
+        int left = range.start, right = range.end - 1;
+        while (left < right) {
+            while (arr[left] < mid && left < right) left++;
+            while (arr[right] >= mid && left < right) right--;
+            std::swap(arr[left], arr[right]);
+        }
+        if (arr[left] >= arr[range.end])
+            std::swap(arr[left], arr[range.end]);
+        else
+            left++;
+        r[p++] = Range(range.start, left - 1);
+        r[p++] = Range(left + 1, range.end);
+    }
 }

Algorithm/SelectionSort.h

@@ -1,19 +1,35 @@
+/*
+
+选择排序思路：
+1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
+2. 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
+3. 以此类推，直到所有元素均排序完毕
+
+*/
+
 // 选择排序
 void SelectionSort(vector<int>& v) {
-	if (v.size() <= 0)
+	int min, len = v.size();
-		return;
+	for (int i = 0; i < len - 1; ++i) {
-	int min, temp;
-	for (int i = 0; i < v.size() - 1; ++i) {
 		min = i;
-		for (int j = i + 1; j < v.size(); ++j) {
+		for (int j = i + 1; j < len; ++j) {
 			if (v[j] < v[min]) {    // 标记最小的
 				min = j;
 			}
 		}
-		if (i != min) { // 交换到前面
+		if (i != min)  // 交换到前面
-			temp = v[i];
+			swap(v[i], v[min]);
-			v[i] = v[min];
+	}
-			v[min] = temp;
+}
-		}
+
+// 模板实现
+template<typename T> 
+void Selection_Sort(std::vector<T>& arr) {
+	for (int i = 0; i < arr.size() - 1; i++) {
+		int min = i;
+		for (int j = i + 1; j < arr.size(); j++)
+			if (arr[j] < arr[min])
+				min = j;
+		std::swap(arr[i], arr[min]);
 	}
 }