以下是10种经典的排序算法,以及它们的原理和用C语言实现的简单示例:
- 冒泡排序 (Bubble Sort):
- 原理:比较相邻的元素,如果顺序错误则交换,每一轮都会将最大(或最小)的元素移动到最后。
- 实现:
void bubbleSort(int arr[], int n) {
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;
}
}
}
}
- 选择排序 (Selection Sort):
- 原理:每次从未排序的元素中选取最小(或最大)的元素,放到已排序序列的末尾。
- 实现:
void selectionSort(int arr[], int n) {
for (int i = 0; i < n-1; i++) {
int minIndex = i;
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
- 插入排序 (Insertion Sort):
- 原理:将待排序元素逐个插入到已排序序列中的合适位置,直到整个序列有序。
- 实现:
void insertionSort(int arr[], int n) {
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;
}
}
- 快速排序 (Quick Sort):
- 原理:选择一个基准元素,将小于基准的元素放在左边,大于基准的元素放在右边,然后对左右两个子序列递归进行快速排序。
- 实现:
int partition(int arr[], int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j <= high-1; 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;
}
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);
}
}
- 归并排序 (Merge Sort):
- 原理:将序列分为两个子序列,分别对子序列进行归并排序,然后将排好序的子序列合并。
- 实现:
void merge(int arr[], int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (int i = 0; i < n1; i++) {
L[i] = arr[l + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[m + 1 + j];
}
int i = 0, j = 0, k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
- 堆排序 (Heap Sort):
- 原理:利用堆的性质进行排序,构建一个最大堆(或最小堆),然后逐步将堆顶元素与末尾元素交换,并重新调整堆,直到整个序列有序。
- 实现:
void heapify(int arr[], int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l] > arr[largest]) {
largest = l;
}
if (r < n && arr[r] > arr[largest]) {
largest = r;
}
if (largest != i) {
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
void heapSort(int arr[], int n) {
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);
}
}
- 计数排序 (Counting Sort):
- 原理:统计每个元素的出现次数,然后根据元素的值和出现次数重新构建序列。
- 实现:
void countingSort(int arr[], int n, int range) {
int output[n];
int count[range+1] = {0};
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
for (int i = 1; i <= range; i++) {
count[i] += count[i-1];
}
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
- 桶排序 (Bucket Sort):
- 原理:将元素分散到多个桶中,对每个桶中的元素进行排序,然后合并桶。
- 实现:
void bucketSort(int arr[], int n, int maxVal) {
int buckets[maxVal + 1];
memset(buckets, 0, sizeof(buckets));
for (int i = 0; i < n; i++) {
buckets[arr[i]]++;
}
int index = 0;
for (int i = 0; i <= maxVal; i++) {
while (buckets[i] > 0) {
arr[index++] = i;
buckets[i]--;
}
}
}
- 基数排序 (Radix Sort):
- 原理:按照位数进行排序,从最低有效位到最高有效位,依次进行稳定排序。
- 实现:
int getMax(int arr[], int n) {
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
void countSort(int arr[], int n, int exp) {
int output[n];
int count[10] = {0};
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]--;
}
for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}
void radixSort(int arr[], int n) {
int max = getMax(arr, n);
for (int exp = 1; max / exp > 0; exp *= 10) {
countSort(arr, n, exp);
}
}
- 希尔排序 (Shell Sort):
- 原理:将待排序数组划分为若干个较小的子数组,对子数组分别进行插入排序,然后逐步减小增量,最终使整个数组有序。
- 实现:
void shellSort(int arr[], int n) {
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;
}
}
}
这些是一些经典的排序算法,每个都有自己的特点和适用场景。选择合适的排序算法取决于数据规模、数据分布和性能要求。