排序与查找算法
排序算法的基本概念
排序算法是计算机科学中的基础算法，主要用于将一组数据按特定顺序排列。排序可以提高数据检索的效率，是数据库和其他数据结构管理中的重要组成部分。常见的排序方式包括升序和降序。
排序算法可以分为两大类：
- 内部排序：数据在内存中排序的算法，如冒泡排序、选择排序、快速排序等。
- 外部排序：处理无法完全放入内存的数据的算法，如归并排序和外部归并排序。
本篇将讨论几种常见的排序算法，包括其实现及复杂度分析。
常见排序算法
冒泡排序
冒泡排序是一种简单的排序算法，其基本思想是通过重复交换相邻逆序的元素将最大的元素“冒泡”到数组的末端。过程重复进行直到数组有序。
-
算法步骤：
- 从头开始，比较相邻的两个元素，如果前一个比后一个大，交换它们。
- 对每一对相邻元素执行这个操作，从第一对到最后一对，执行完后，最后的元素是最大的。
- 重复以上步骤，逐渐减少比较的元素。
-
实现代码：
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = {64, 34, 25, 12, 22, 11, 90};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("排序后的数组：\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 时间复杂度：O(n²)，最坏和平均情况下。
- 空间复杂度：O(1)，因为仅使用了常数级别的额外空间。
选择排序
选择排序的基本思想是每次从未排序序列中选择最小（或最大）的元素，将其放到已排序序列的末尾。它的每个步骤中都会选择出一个最小值。
-
算法步骤：
- 从未排序的部分找到最小的元素，并将其放到数组的前面。
- 从剩下的元素中重复这个过程。
-
实现代码：
#include <stdio.h>
void selectionSort(int arr[], int n) {
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;
}
}
int main() {
int arr[] = {64, 25, 12, 22, 11};
int n = sizeof(arr) / sizeof(arr[0]);
selectionSort(arr, n);
printf("排序后的数组：\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 时间复杂度：O(n²)，无论是在最坏、平均还是最好情况下。
- 空间复杂度：O(1)，因为仅使用了常数级别的额外空间。
插入排序
插入排序是一种简单的排序算法，它构建最终的排序数组（或序列）。它逐步将元素插入到已排序的部分中。
-
算法步骤：
- 从第一个元素开始，认为它是已经排序的。
- 从第二个元素开始，取出当前元素并在前面已排序的部分中找到合适的位置插入。
- 重复以上步骤，直到所有元素都排序完毕。
-
实现代码：
#include <stdio.h>
void insertionSort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
// 将arr[i]与前面的已排序元素逐个进行比较并插入
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6};
int n = sizeof(arr) / sizeof(arr[0]);
insertionSort(arr, n);
printf("排序后的数组：\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 时间复杂度：O(n²)，最坏情况下，最好情况下O(n)（当数组已排序时）。
- 空间复杂度：O(1)。
快速排序
快速排序是一种分治算法，其基本思想是首先选择一个“基准”元素，然后将其他元素分成两个部分：小于基准的元素和大于基准的元素，分别对这两个部分进行排序。
-
算法步骤：
- 选择一个基准元素（通常选择第一个、最后一个或中间的元素）。
- 从数组两端开始，比较并交换元素，使得左边的元素小于基准，右边的元素大于基准。
- 对基准元素两侧的子数组进行递归快速排序。
-
实现代码：
#include <stdio.h>
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);
}
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); // 对右侧子数组进行排序
}
}
int main() {
int arr[] = {10, 7, 8, 9, 1, 5};
int n = sizeof(arr) / sizeof(arr[0]);
quickSort(arr, 0, n - 1);
printf("排序后的数组：\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 时间复杂度：O(n log n) 平均情况下；O(n²) 最坏情况下（当数组已接近有序）。
- 空间复杂度：O(log n)（递归调用栈）。
归并排序
归并排序也是一种分治算法，它将数组分成两个子数组，对每个子数组进行排序，然后将它们合并成一个有序的数组。
-
算法步骤：
- 将数组从中间分成两个子数组。
- 对两个子数组进行递归归并排序。
- 合并两个已排序的子数组。
-
实现代码：
#include <stdio.h>
void merge(int arr[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;
// 创建临时数组
int L[n1], R[n2];
// 拷贝数据到临时数组
for (i = 0; i < n1; i++)
L[i] = arr[left + i];
for (j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
// 合并临时数组
i = 0; // 初始化第一个子数组的索引
j = 0; // 初始化第二个子数组的索引
k = left; // 初始化主数组的索引
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 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); // 合并
}
}
int main() {
int arr[] = {12, 11, 13, 5, 6, 7};
int n = sizeof(arr) / sizeof(arr[0]);
mergeSort(arr, 0, n - 1);
printf("排序后的数组：\n");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
- 时间复杂度：O(n log n)，无论在最坏、最好还是平均情况下。
- 空间复杂度：O(n)（需要临时数组）。
查找算法
查找算法用于在数据集中查找特定的元素。常见的查找算法分为线性查找和二分查找。
线性查找
线性查找是一种简单的查找方法，它遍历数组的每一个元素，直到找到所需的元素或者遍历完整个数组。
- 实现代码：
#include <stdio.h>
int linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key) {
return i; // 返回找到的索引
}
}
return -1; // 未找到
}
int main() {
int arr[] = {7, 2, 1, 8, 3};
int n = sizeof(arr) / sizeof(arr[0]);
int key = 3;
int result = linearSearch(arr, n, key);
if (result != -1) {
printf("元素 %d 在数组中的索引为: %d\n", key, result);
} else {
printf("元素 %d 未找到\n", key);
}
return 0;
}
- 时间复杂度：O(n)，最坏和平均情况下。
- 空间复杂度：O(1)。
二分查找
二分查找是一种高效的查找方法，适用于已排序的数组。它通过将查找范围分成两半来逐步缩小查找范围。
-
算法步骤：
- 确定查找范围的中间元素。
- 比较中间元素与目标元素：
- 如果中间元素等于目标，返回索引。
- 如果目标小于中间元素，缩小查找范围到左半部分。
- 如果目标大于中间元素，缩小查找范围到右半部分。
- 重复以上步骤。
-
实现代码：
#include <stdio.h>
int binarySearch(int arr[], int n, int key) {
int low = 0;
int high = n - 1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
return mid; // 找到元素
} else if (arr[mid] < key) {
low = mid + 1; // 缩小范围到右侧
} else {
high = mid - 1; // 缩小范围到左侧
}
}
return -1; // 未找到
}
int main() {
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9}; // 必须是排序后的数组
int n = sizeof(arr) / sizeof(arr[0]);
int key = 4;
int result = binarySearch(arr, n, key);
if (result != -1) {
printf("元素 %d 在数组中的索引为: %d\n", key, result);
} else {
printf("元素 %d 未找到\n", key);
}
return 0;
}
- 时间复杂度：O(log n)，最坏情况下。
- 空间复杂度：O(1)，迭代版本。
总结
排序与查找的总结
排序和查找是计算机科学中的两个基本操作，理解不同类型的排序算法和查找算法的特性对于编写高效的程序至关重要。这些算法在软件开发、数据库管理和数据分析等领域都有广泛的应用。
- 选择合适的排序算法：在选择排序算法时要考虑数据规模、数据是否预先排序以及算法的时间和空间复杂度。例如，若需要稳定排序且数据量较小，可选择插入排序；若数据量大且无序，快速排序可能更合适。
- 选择查找算法：在进行查找时，若数据是无序的，可选择线性查找；而对于已排序的数据，推荐使用二分查找以提高查找效率。
扫一扫
1201
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
