目录
在编程和算法领域，排序和搜索是最常见的两类基本操作。排序可以将数据按照特定顺序排列，以便提高检索效率；而搜索则是在数据中找到目标值的过程。冒泡排序、快速排序和选择排序是三种常用的排序方法，各有特点。搜索方面，二分查找适用于有序数据，而深度优先搜索（DFS）和广度优先搜索（BFS）则广泛应用于图论和树结构的遍历。本文将从理论和代码实现的角度，剖析这些基础算法的原理、优缺点及其应用场景。
一、排序算法
1. 冒泡排序
原理：通过多次比较相邻元素，将最大的元素“冒泡”到数组的最后位置。
实现：双层循环，一层控制遍历次数，另一层进行相邻元素的比较与交换。
比喻：
冒泡排序就像在水池里吹气泡，重的东西（大的数）会慢慢沉下去，轻的东西（小的数）会逐渐上浮。每次比较相邻的两个元素，把大的往后移，最终最大的一个会被送到“池底”（数组末尾）。
场景：
想象你在整理扑克牌，每次从头开始比较相邻的两张，发现顺序不对就交换，直到最重的牌（最大值）沉到最右边。
特点：
时间复杂度：O(n²)
优点：实现简单，适合小规模数据。
缺点：效率较低，不适合大规模数据。
代码实现（C++）：
#include <stdio.h>
// 冒泡排序函数
// arr: 待排序的数组
// n: 数组中元素的数量
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]) {
// 交换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("Sorted array: ");
for (int i = 0; i < n; i++) {
// 打印当前元素
printf("%d ", arr[i]);
}
// 换行
printf("\n");
return 0;
}2. 选择排序
原理：每次从未排序的部分选择最小的元素，放到已排序部分的末尾。
比喻：
选择排序就像选班级里最高的同学站到队伍最右边（最大值），接着在剩下的人里找次高的站到倒数第二位，以此类推，直到队伍排好。
场景：
比如你从一堆硬币中挑最重的硬币放在第一堆，再从剩下的硬币中挑次重的，放在第二堆，依此类推。
特点：
时间复杂度：O(n²)
优点：内存移动次数少，适合内存写入较高代价的场景。
缺点：效率低，不适合大规模数据。
代码实现（C）：
#include <stdio.h>
// 选择排序函数定义
void selectionSort(int arr[], int n) {
// 外层循环控制排序的轮数
for (int i = 0; i < n - 1; i++) {
// 假设当前轮中最小的元素的索引为i
int minIdx = i;
// 内层循环用于找出比当前假设的最小值还要小的元素
for (int j = i + 1; j < n; j++) {
// 如果找到更小的元素，更新最小元素的索引
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
// 如果最小元素不是当前轮的起始元素，则交换它们
int temp = arr[i];
arr[i] = arr[minIdx];
arr[minIdx] = temp;
}
}
// 主函数
int main() {
// 初始化一个整型数组
int arr[] = {29, 10, 14, 37, 13};
// 计算数组中元素的数量
int n = sizeof(arr) / sizeof(arr[0]);
// 调用选择排序函数对数组进行排序
selectionSort(arr, n);
// 打印排序后的数组
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
// 打印当前元素
printf("%d ", arr[i]);
}
// 换行
printf("\n");
return 0;
}3.快速排序
原理：通过选择一个基准值（pivot），将数组分为比基准值小的部分和大的部分，递归地进行排序。
比喻：
快速排序就像在搬家时整理物品：你先挑一个盒子（基准值），把所有轻的东西（比基准值小的）放左边，重的东西（比基准值大的）放右边，然后再分别对左边和右边重复这个动作，直到每个小区域的东西都整理好了。
场景：
比如整理书架，先随便选一本书（基准），把比它小的书放到左边，比它大的书放到右边，再对左右两部分重复整理。
特点：
时间复杂度：平均为 O(n log n)，最差为 O(n²)。
优点：效率高，适合大规模数据。
缺点：递归调用会占用栈空间。
代码实现（C）：
#include <stdio.h>
// 快速排序函数声明
void quickSort(int arr[], int low, int high);
// 分区函数声明
int partition(int arr[], int low, int high);
// 快速排序函数定义
void quickSort(int arr[], int low, int high) {
// 如果low小于high，说明还有元素未排序
if (low < high) {
// 进行分区操作，返回基准元素的索引
int pi = partition(arr, low, high);
// 对基准左边的子数组进行快速排序
quickSort(arr, low, pi - 1);
// 对基准右边的子数组进行快速排序
quickSort(arr, pi + 1, high);
}
}
// 分区函数定义
int partition(int arr[], int low, int high) {
// 选择最后一个元素作为基准
int pivot = arr[high];
// i初始化为low-1，用于在循环中跟踪比基准小的元素的最后一个位置
int i = low - 1;
// 循环遍历数组，直到high-1的位置
for (int j = low; j < high; j++) {
// 如果当前元素小于基准
if (arr[j] < pivot) {
// i加1，交换arr[i]和arr[j]
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// 交换基准和arr[i+1]，确保基准左边的元素都比它小，右边的元素都比它大
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
// 返回基准的索引
return i + 1;
}
// 主函数
int main() {
// 初始化一个整型数组
int arr[] = {10, 7, 8, 9, 1, 5};
// 计算数组中元素的数量
int n = sizeof(arr) / sizeof(arr[0]);
// 对整个数组进行快速排序
quickSort(arr, 0, n - 1);
// 打印排序后的数组
printf("Sorted array: ");
for (int i = 0; i < n; i++) {
// 打印当前元素
printf("%d ", arr[i]);
}
// 换行
printf("\n");
return 0;
}二、搜索算法
1. 二分查找
原理：在有序数组中，通过比较目标值与中间值，不断缩小搜索范围。
比喻：
二分搜索就像在字典里查一个单词。你不会从第一页开始一页一页地翻，而是打开大概中间的页面，看看目标单词是在前面还是后面，然后继续翻开前半部分或后半部分，再次对半查找。
场景：
想象一个100层的楼房，你要找一个人住在哪一层。你从中间50层开始问管理员，然后根据回答往上或往下继续找，直到找到目标楼层。
特点：
时间复杂度：O(log n)
优点：效率高，适合有序数组。
缺点：仅适用于有序数据。
代码实现（C）：
#include <stdio.h>
// 二分查找函数定义
// arr: 待查找的有序数组
// n: 数组中元素的数量
// target: 要查找的目标值
int binarySearch(int arr[], int n, int target) {
// 初始化搜索范围的上下界
int low = 0, high = n - 1;
// 当搜索范围的上下界有重叠时，继续查找
while (low <= high) {
// 计算中间位置的索引
int mid = low + (high - low) / 2;
// 如果中间元素等于目标值，返回中间位置的索引
if (arr[mid] == target) {
return mid;
// 如果中间元素小于目标值，说明目标值在中间元素的右侧
} else if (arr[mid] < target) {
low = mid + 1;
// 如果中间元素大于目标值，说明目标值在中间元素的左侧
} else {
high = mid - 1;
}
}
// 如果未找到目标值，返回-1
return -1;
}
// 主函数
int main() {
// 初始化一个有序整型数组
int arr[] = {2, 3, 4, 10, 40};
// 计算数组中元素的数量
int n = sizeof(arr) / sizeof(arr[0]);
// 设置要查找的目标值
int target = 10;
// 调用二分查找函数
int result = binarySearch(arr, n, target);
// 根据返回的结果判断目标值是否存在于数组中
if (result != -1) {
// 如果存在，打印目标值的位置
printf("Element is present at index %d\n", result);
} else {
// 如果不存在，打印目标值不在数组中的消息
printf("Element is not present in array\n");
}
return 0;
}2. 深度优先搜索（DFS）
原理：优先深入树或图的一个分支，直到无法继续，再回溯到上一层。
比喻：
深度优先搜索就像走迷宫：你沿着一条路径一直走到底，直到无路可走再返回上一个分叉点，换另一条路继续走，直到找到出口。
场景：
你在超市找某个商品，你可能先从一个货架的最底层开始找，然后从底到顶找完这个货架，再移动到下一个货架。
特点：
时间复杂度：O(V+E)，V 为顶点数，E 为边数。
优点：适合解决路径相关问题，如迷宫问题。
缺点：可能陷入无限递归（需配合标记）。
代码实现（C）：
#include <stdio.h>
#include <stdbool.h>
#define MAX 100 // 定义图的最大顶点数
// 深度优先搜索（DFS）函数
// 参数：
// - graph: 图的邻接矩阵表示
// - visited: 记录每个顶点是否被访问过的布尔数组
// - v: 图中顶点的数量
// - start: 开始搜索的起始顶点
void DFS(int graph[MAX][MAX], bool visited[], int v, int start) {
printf("%d ", start); // 打印当前访问的顶点
visited[start] = true; // 标记当前顶点为已访问
// 遍历所有顶点，检查是否有未访问的相邻顶点
for (int i = 0; i < v; i++) {
// 如果存在边且该顶点未被访问，则递归调用DFS进行深度优先遍历
if (graph[start][i] == 1 && !visited[i]) {
DFS(graph, visited, v, i);
}
}
}
int main() {
// 定义一个无向图的邻接矩阵表示
int graph[MAX][MAX] = {
{0, 1, 1, 0}, // 顶点0与顶点1和2相连
{1, 0, 0, 1}, // 顶点1与顶点0和3相连
{1, 0, 0, 1}, // 顶点2与顶点0和3相连
{0, 1, 1, 0} // 顶点3与顶点1和2相连
};
int vertices = 4; // 图中的顶点数量
bool visited[MAX] = {false}; // 初始化所有顶点为未访问状态
// 打印从顶点0开始的深度优先搜索路径
printf("从顶点 0 开始的深度优先搜索: ");
DFS(graph, visited, vertices, 0);
return 0;
}3. 广度优先搜索（BFS）
原理：按层次从树或图的根节点向外扩展，先访问当前层的所有节点，再访问下一层。
比喻：
广度优先搜索就像浇灌农田：你从水渠开始，第一步先灌溉水渠附近的农田（第1层节点），然后再扩散到稍远的农田（第2层节点），一步步扩展到整个农田。
场景：
你在寻找朋友时，先找你认识的朋友（直接相连的第1层节点），再让他们帮你介绍他们的朋友（第2层节点），以此类推。
特点：
时间复杂度：O(V+E)
优点：适合寻找最短路径问题。
缺点：需要额外的队列存储。
代码实现（C）：
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define MAX 100
// 广度优先搜索函数定义
// graph: 邻接矩阵表示的图
// v: 图中顶点的数量
// start: 起始顶点的索引
void BFS(int graph[MAX][MAX], int v, int start) {
// 访问标记数组，初始化为false
bool visited[MAX] = {false};
// 队列，用于存储待访问的顶点
int queue[MAX], front = 0, rear = 0;
// 将起始顶点加入队列
queue[rear++] = start;
// 标记起始顶点为已访问
visited[start] = true;
// 当队列不为空时，继续遍历
while (front < rear) {
// 从队列中取出一个顶点
int current = queue[front++];
printf("%d ", current);
// 遍历当前顶点的所有邻接顶点
for (int i = 0; i < v; i++) {
// 如果邻接顶点未被访问过
if (graph[current][i] == 1 && !visited[i]) {
// 将邻接顶点加入队列
queue[rear++] = i;
// 标记邻接顶点为已访问
visited[i] = true;
}
}
}
}
// 主函数
int main() {
// 定义一个4x4的邻接矩阵，表示一个图
int graph[MAX][MAX] = {
{0, 1, 1, 0},
{1, 0, 0, 1},
{1, 0, 0, 1},
{0, 1, 1, 0}
};
// 图中顶点的数量
int vertices = 4;
// 打印广度优先搜索的起始顶点
printf("BFS starting from vertex 0: ");
// 调用BFS函数，从顶点0开始遍历
BFS(graph, vertices, 0);
return 0;
}排序和搜索算法是计算机科学的核心部分，无论是数据的组织还是问题的求解，都离不开它们。冒泡、快速、选择排序各有优势，适合不同的应用场景；而二分查找、深度优先搜索和广度优先搜索则提供了高效的数据搜索方式。在实际项目中，根据数据规模和需求选择合适的算法，能显著提升程序性能。理解这些基础算法，将为复杂问题的解决提供扎实的基础。
扫一扫
356
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
