作为资深程序员，我来为你生成。每种算法都有详细的注释说明。
## C++ 实现
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
// 1. 冒泡排序
void bubbleSort(vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr[j], arr[j + 1]);
}
}
}
}
// 2. 选择排序
void selectionSort(vector<int>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
swap(arr[i], arr[minIdx]);
}
}
// 3. 插入排序
void insertionSort(vector<int>& arr) {
int n = arr.size();
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
// 4. 希尔排序
void shellSort(vector<int>& arr) {
int n = arr.size();
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
// 5. 归并排序
void merge(vector<int>& arr, int left, int mid, int right) {
vector<int> temp(right - left + 1);
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
for (int p = 0; p < k; p++) {
arr[left + p] = temp[p];
}
}
void mergeSort(vector<int>& arr, int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
void mergeSort(vector<int>& arr) {
mergeSort(arr, 0, arr.size() - 1);
}
// 6. 快速排序
int partition(vector<int>& arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
swap(arr[i], arr[j]);
}
}
swap(arr[i + 1], arr[high]);
return i + 1;
}
void quickSort(vector<int>& arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
void quickSort(vector<int>& arr) {
quickSort(arr, 0, arr.size() - 1);
}
// 7. 堆排序
void heapify(vector<int>& arr, int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i) {
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
}
}
void heapSort(vector<int>& arr) {
int n = arr.size();
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
// 一个个提取元素
for (int i = n - 1; i > 0; i--) {
swap(arr[0], arr[i]);
heapify(arr, i, 0);
}
}
// 8. 计数排序
void countingSort(vector<int>& arr) {
if (arr.empty()) return;
int max_val = *max_element(arr.begin(), arr.end());
int min_val = *min_element(arr.begin(), arr.end());
int range = max_val - min_val + 1;
vector<int> count(range), output(arr.size());
for (int i = 0; i < arr.size(); i++)
count[arr[i] - min_val]++;
for (int i = 1; i < range; i++)
count[i] += count[i - 1];
for (int i = arr.size() - 1; i >= 0; i--) {
output[count[arr[i] - min_val] - 1] = arr[i];
count[arr[i] - min_val]--;
}
arr = output;
}
// 9. 桶排序
void bucketSort(vector<int>& arr) {
if (arr.empty()) return;
int n = arr.size();
int max_val = *max_element(arr.begin(), arr.end());
int min_val = *min_element(arr.begin(), arr.end());
// 创建桶
int bucket_count = n;
vector<vector<int>> buckets(bucket_count);
// 将元素分配到桶中
for (int i = 0; i < n; i++) {
int bucket_index = (arr[i] - min_val) * (bucket_count - 1) / (max_val - min_val);
buckets[bucket_index].push_back(arr[i]);
}
// 对每个桶排序
for (int i = 0; i < bucket_count; i++) {
sort(buckets[i].begin(), buckets[i].end());
}
// 合并桶
int index = 0;
for (int i = 0; i < bucket_count; i++) {
for (int j = 0; j < buckets[i].size(); j++) {
arr[index++] = buckets[i][j];
}
}
}
// 10. 基数排序
void radixSort(vector<int>& arr) {
if (arr.empty()) return;
int max_val = *max_element(arr.begin(), arr.end());
// 对每个位数进行计数排序
for (int exp = 1; max_val / exp > 0; exp *= 10) {
vector<int> output(arr.size());
vector<int> count(10, 0);
for (int i = 0; i < arr.size(); i++)
count[(arr[i] / exp) % 10]++;
for (int i = 1; i < 10; i++)
count[i] += count[i - 1];
for (int i = arr.size() - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
arr = output;
}
}
// 测试函数
void testSorts() {
vector<int> arr = {64, 34, 25, 12, 22, 11, 90, 5};
vector<int> temp;
cout << "原始数组: ";
for (int x : arr) cout << x << " ";
cout << endl;
// 测试每种排序
vector<void (*)(vector<int>&)> sorts = {
bubbleSort, selectionSort, insertionSort, shellSort,
mergeSort, quickSort, heapSort, countingSort,
bucketSort, radixSort
};
vector<string> sortNames = {
"冒泡排序", "选择排序", "插入排序", "希尔排序",
"归并排序", "快速排序", "堆排序", "计数排序",
"桶排序", "基数排序"
};
for (int i = 0; i < sorts.size(); i++) {
temp = arr;
sorts[i](temp);
cout << sortNames[i] << ": ";
for (int x : temp) cout << x << " ";
cout << endl;
}
}
int main() {
testSorts();
return 0;
}
```
## Java 实现
```java
import java.util.*;
public class SortingAlgorithms {
// 1. 冒泡排序
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// 2. 选择排序
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}
// 3. 插入排序
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
// 4. 希尔排序
public static void shellSort(int[] arr) {
int n = arr.length;
for (int gap = n / 2; gap > 0; gap /= 2) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
}
}
// 5. 归并排序
public static void mergeSort(int[] arr) {
mergeSort(arr, 0, arr.length - 1);
}
private static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
private static void merge(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
System.arraycopy(temp, 0, arr, left, temp.length);
}
// 6. 快速排序
public static void quickSort(int[] arr) {
quickSort(arr, 0, arr.length - 1);
}
private static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
private static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] <= pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
// 7. 堆排序
public static void heapSort(int[] arr) {
int n = arr.length;
// 构建最大堆
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
// 一个个提取元素
for (int i = n - 1; i > 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
private static void heapify(int[] arr, int n, int i) {
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i) {
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
// 8. 计数排序
public static void countingSort(int[] arr) {
if (arr.length == 0) return;
int maxVal = Arrays.stream(arr).max().getAsInt();
int minVal = Arrays.stream(arr).min().getAsInt();
int range = maxVal - minVal + 1;
int[] count = new int[range];
int[] output = new int[arr.length];
for (int i = 0; i < arr.length; i++)
count[arr[i] - minVal]++;
for (int i = 1; i < range; i++)
count[i] += count[i - 1];
for (int i = arr.length - 1; i >= 0; i--) {
output[count[arr[i] - minVal] - 1] = arr[i];
count[arr[i] - minVal]--;
}
System.arraycopy(output, 0, arr, 0, arr.length);
}
// 9. 桶排序
public static void bucketSort(int[] arr) {
if (arr.length == 0) return;
int n = arr.length;
int maxVal = Arrays.stream(arr).max().getAsInt();
int minVal = Arrays.stream(arr).min().getAsInt();
// 创建桶
int bucketCount = n;
List<List<Integer>> buckets = new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
buckets.add(new ArrayList<>());
}
// 将元素分配到桶中
for (int value : arr) {
int bucketIndex = (value - minVal) * (bucketCount - 1) / (maxVal - minVal);
buckets.get(bucketIndex).add(value);
}
// 对每个桶排序并合并
int index = 0;
for (List<Integer> bucket : buckets) {
Collections.sort(bucket);
for (int value : bucket) {
arr[index++] = value;
}
}
}
// 10. 基数排序
public static void radixSort(int[] arr) {
if (arr.length == 0) return;
int maxVal = Arrays.stream(arr).max().getAsInt();
for (int exp = 1; maxVal / exp > 0; exp *= 10) {
countingSortByDigit(arr, exp);
}
}
private static void countingSortByDigit(int[] arr, int exp) {
int n = arr.length;
int[] output = new int[n];
int[] count = new int[10];
for (int i = 0; i < n; i++)
count[(arr[i] / exp) % 10]++;
for (int i = 1; i < 10; i++)
count[i] += count[i - 1];
for (int i = n - 1; i >= 0; i--) {
output[count[(arr[i] / exp) % 10] - 1] = arr[i];
count[(arr[i] / exp) % 10]--;
}
System.arraycopy(output, 0, arr, 0, n);
}
// 测试函数
public static void testSorts() {
int[] original = {64, 34, 25, 12, 22, 11, 90, 5};
System.out.print("原始数组: ");
System.out.println(Arrays.toString(original));
// 测试每种排序
testSort("冒泡排序", original, SortingAlgorithms::bubbleSort);
testSort("选择排序", original, SortingAlgorithms::selectionSort);
testSort("插入排序", original, SortingAlgorithms::insertionSort);
testSort("希尔排序", original, SortingAlgorithms::shellSort);
testSort("归并排序", original, SortingAlgorithms::mergeSort);
testSort("快速排序", original, SortingAlgorithms::quickSort);
testSort("堆排序", original, SortingAlgorithms::heapSort);
testSort("计数排序", original, SortingAlgorithms::countingSort);
testSort("桶排序", original, SortingAlgorithms::bucketSort);
testSort("基数排序", original, SortingAlgorithms::radixSort);
}
private static void testSort(String name, int[] original, Consumer<int[]> sorter) {
int[] arr = original.clone();
sorter.accept(arr);
System.out.println(name + ": " + Arrays.toString(arr));
}
@FunctionalInterface
interface Consumer<T> {
void accept(T t);
}
public static void main(String[] args) {
testSorts();
}
}
```
## Python 实现
```python
def bubble_sort(arr):
"""1. 冒泡排序"""
n = len(arr)
for i in range(n - 1):
for j in range(n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] = arr[j + 1], arr[j]
def selection_sort(arr):
"""2. 选择排序"""
n = len(arr)
for i in range(n - 1):
min_idx = i
for j in range(i + 1, n):
if arr[j] < arr[min_idx]:
min_idx = j
arr[i], arr[min_idx] = arr[min_idx], arr[i]
def insertion_sort(arr):
"""3. 插入排序"""
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
def shell_sort(arr):
"""4. 希尔排序"""
n = len(arr)
gap = n // 2
while gap > 0:
for i in range(gap, n):
temp = arr[i]
j = i
while j >= gap and arr[j - gap] > temp:
arr[j] = arr[j - gap]
j -= gap
arr[j] = temp
gap //= 2
def merge_sort(arr):
"""5. 归并排序"""
if len(arr) > 1:
mid = len(arr) // 2
left = arr[:mid]
right = arr[mid:]
merge_sort(left)
merge_sort(right)
i = j = k = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
arr[k] = left[i]
i += 1
else:
arr[k] = right[j]
j += 1
k += 1
while i < len(left):
arr[k] = left[i]
i += 1
k += 1
while j < len(right):
arr[k] = right[j]
j += 1
k += 1
def quick_sort(arr):
"""6. 快速排序"""
_quick_sort(arr, 0, len(arr) - 1)
def _quick_sort(arr, low, high):
if low < high:
pi = partition(arr, low, high)
_quick_sort(arr, low, pi - 1)
_quick_sort(arr, pi + 1, high)
def partition(arr, low, high):
pivot = arr[high]
i = low - 1
for j in range(low, high):
if arr[j] <= pivot:
i += 1
arr[i], arr[j] = arr[j], arr[i]
arr[i + 1], arr[high] = arr[high], arr[i + 1]
return i + 1
def heap_sort(arr):
"""7. 堆排序"""
n = len(arr)
# 构建最大堆
for i in range(n // 2 - 1, -1, -1):
heapify(arr, n, i)
# 一个个提取元素
for i in range(n - 1, 0, -1):
arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)
def heapify(arr, n, i):
largest = i
left = 2 * i + 1
right = 2 * i + 2
if left < n and arr[left] > arr[largest]:
largest = left
if right < n and arr[right] > arr[largest]:
largest = right
if largest != i:
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
def counting_sort(arr):
"""8. 计数排序"""
if not arr:
return
max_val = max(arr)
min_val = min(arr)
range_val = max_val - min_val + 1
count = [0] * range_val
output = [0] * len(arr)
for num in arr:
count[num - min_val] += 1
for i in range(1, range_val):
count[i] += count[i - 1]
for i in range(len(arr) - 1, -1, -1):
output[count[arr[i] - min_val] - 1] = arr[i]
count[arr[i] - min_val] -= 1
for i in range(len(arr)):
arr[i] = output[i]
def bucket_sort(arr):
"""9. 桶排序"""
if not arr:
return
n = len(arr)
max_val = max(arr)
min_val = min(arr)
# 创建桶
bucket_count = n
buckets = [[] for _ in range(bucket_count)]
# 将元素分配到桶中
for num in arr:
if max_val == min_val:
bucket_index = 0
else:
bucket_index = (num - min_val) * (bucket_count - 1) // (max_val - min_val)
buckets[bucket_index].append(num)
# 对每个桶排序并合并
index = 0
for bucket in buckets:
bucket.sort()
for num in bucket:
arr[index] = num
index += 1
def radix_sort(arr):
"""10. 基数排序"""
if not arr:
return
max_val = max(arr)
exp = 1
while max_val // exp > 0:
counting_sort_by_digit(arr, exp)
exp *= 10
def counting_sort_by_digit(arr, exp):
n = len(arr)
output = [0] * n
count = [0] * 10
for num in arr:
index = (num // exp) % 10
count[index] += 1
for i in range(1, 10):
count[i] += count[i - 1]
for i in range(n - 1, -1, -1):
index = (arr[i] // exp) % 10
output[count[index] - 1] = arr[i]
count[index] -= 1
for i in range(n):
arr[i] = output[i]
def test_sorts():
"""测试所有排序算法"""
original = [64, 34, 25, 12, 22, 11, 90, 5]
print(f"原始数组: {original}")
# 所有排序函数
sort_functions = [
(bubble_sort, "冒泡排序"),
(selection_sort, "选择排序"),
(insertion_sort, "插入排序"),
(shell_sort, "希尔排序"),
(merge_sort, "归并排序"),
(quick_sort, "快速排序"),
(heap_sort, "堆排序"),
(counting_sort, "计数排序"),
(bucket_sort, "桶排序"),
(radix_sort, "基数排序")
]
for sort_func, name in sort_functions:
arr = original.copy()
sort_func(arr)
print(f"{name}: {arr}")
if __name__ == "__main__":
test_sorts()
```
## 算法复杂度总结
| 排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 稳定性 |
|---------|--------------|---------|---------|-----------|--------|
| 冒泡排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
| 选择排序 | O(n²) | O(n²) | O(n²) | O(1) | 不稳定 |
| 插入排序 | O(n²) | O(n) | O(n²) | O(1) | 稳定 |
| 希尔排序 | O(n log n) | O(n log² n) | O(n²) | O(1) | 不稳定 |
| 归并排序 | O(n log n) | O(n log n) | O(n log n) | O(n) | 稳定 |
| 快速排序 | O(n log n) | O(n log n) | O(n²) | O(log n) | 不稳定 |
| 堆排序 | O(n log n) | O(n log n) | O(n log n) | O(1) | 不稳定 |
| 计数排序 | O(n + k) | O(n + k) | O(n + k) | O(k) | 稳定 |
| 桶排序 | O(n + k) | O(n + k) | O(n²) | O(n + k) | 稳定 |
| 基数排序 | O(n × k) | O(n × k) | O(n × k) | O(n + k) | 稳定 |
这些实现涵盖了所有主要的排序算法，每种实现都有详细的注释和测试代码。你可以根据需要选择适合特定场景的排序算法。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
