数组是计算机科学中的一种基础数据结构，它在算法中有着广泛的应用，其关键要素是索引与索引对应的值。
请注意，这些代码示例需要适当的辅助函数（如 swap ）和主函数来运行。此外，一些算法（如KMP算法）需要额外的辅助函数来计算最长公共前缀数组（LPS）。
以下是数组在算法中的一些常见应用:
1 排序
1.1 冒泡排序
通过重复交换相邻元素来排序数组。
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])
swap(&arr[j], &arr[j+1]);
}
1.2 选择排序
每次从未排序的部分选择最小（或最大）的元素放到已排序序列的末尾。
void selectionSort(int arr[], int n) {
int i, j, min_idx;
for (i = 0; i < n-1; i++) {
min_idx = i;
for (j = i + 1; j < n; j++) {
if (arr[j] < arr[min_idx]) {
min_idx = j;
}
}
if (min_idx != i) {
int temp = arr[i];
arr[i] = arr[min_idx];
arr[min_idx] = temp;
}
}
}
1.3 插入排序
构建有序序列，对未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
void insertionSort(int arr[], int n) {
int i, key, j;
// 从第二个元素开始遍历数组
for (i = 1; i < n; i++) {
key = arr[i]; // 选择未排序部分的第一个元素
j = i - 1;
// 将选中的元素与已排序部分的元素比较，并将已排序元素向后移动
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
// 将选中的元素插入到正确的位置
arr[j + 1] = key;
}
}
1.4 快速排序
选择一个“基准”元素，将数组分为两部分，一部分比基准小，另一部分比基准大，然后递归排序这两部分。
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1); // Before pi
quickSort(arr, pi + 1, high); // After pi
}
}
int partition(int arr[], int low, int high) {
int pivot = arr[high]; // pivot
int i = (low - 1); // Index of smaller element
for (int j = low; j <= high - 1; j++) {
// If current element is smaller than or equal to pivot
if (arr[j] <= pivot) {
i++; // increment index of smaller element
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void swap(int* a, int* b) {
int t = *a;
*a = *b;
*b = t;
}
2 搜索
2.1 线性搜索
遍历数组，直到找到目标元素。
int linearSearch(int arr[], int n, int x) {
for (int i = 0; i < n; i++) {
if (arr[i] == x) {
return i; // 找到元素，返回索引
}
}
return -1; // 未找到元素，在返回-1
}
2.2 二分搜索
在已排序的数组中，通过比较中间元素与目标值来减少搜索范围。
int binarySearch(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x)
return mid;
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
3 动态规划
动态规划（Dynamic Programming，简称DP）是一种在数学、管理科学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。
用于解决具有重叠子问题和最优子结构特性的问题，如斐波那契数列、最长公共子序列、背包问题等。
3.1 斐波那契
int fib(int n) {
int f[n+2]; // 1 extra to handle case, n = 0
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++) {
f[i] = f[i-1] + f[i-2];
}
return f[n];
}
3.2 最长公共子序列
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 动态规划求解最长公共子序列的长度
int lcs_length(char *X, char *Y, int m, int n) {
int L[m+1][n+1];
int i, j;
// 构建L[m+1][n+1]表
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i-1] == Y[j-1])
L[i][j] = L[i-1][j-1] + 1;
else
L[i][j] = (L[i-1][j] > L[i][j-1]) ? L[i-1][j] : L[i][j-1];
}
}
// L[m][n]包含了X[0..m-1]和Y[0..n-1]的LCS的长度
return L[m][n];
}
3.3 背包问题
背包问题是一种组合优化的问题。在典型的背包问题中，你给定一组物品，每个物品都有自己的重量和价值，并且存在一个限定的总重量。目标是确定在不超过总重量的前提下，哪些物品应该被选中，以使得总价值最大化。
这里提供的是0-1背包问题的动态规划解决方案的C语言实现。0-1背包问题是指每个物品只有两种选择：要么完全拿走，要么完全不要。
#include <stdio.h>
// 动态规划求解0-1背包问题
int knapSack(int W, int wt[], int val[], int n) {
int i, w;
int K[n+1][W+1];
// 构建dp表
for (i = 0; i <= n; i++) {
for (w = 0; w <= W; w++) {
if (i == 0 || w == 0)
K[i][w] = 0;
else if (wt[i - 1] <= w)
K[i][w] = (val[i - 1] + K[i - 1][w - wt[i - 1]]) > K[i - 1][w] ? (val[i - 1] + K[i - 1][w - wt[i - 1]]) : K[i - 1][w];
else
K[i][w] = K[i - 1][w];
}
}
// 返回最大价值
return K[n][W];
}
4 图算法
4.1 邻接矩阵
表示图中顶点间连接关系的二维数组。
#define V 5 // 5 vertices
void addEdge(int graph[V][V], int src, int dest) {
graph[src][dest] = 1;
graph[dest][src] = 1; // For undirected graph
}
void printGraph(int graph[V][V]) {
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
printf("%d ", graph[i][j]);
}
printf("\n");
}
}
4.2 最短路径问题
（如Dijkstra算法、Bellman-Ford算法）。
4.2.1 Dijkstra算法
最短路径问题是图论中的一个经典问题，其中Dijkstra算法是求解单源最短路径问题的一种非常著名的算法。
#include <stdio.h>
#include <limits.h>
// 用于找到最短路径集合中具有最小距离的顶点
int minDistance(int dist[], int sptSet[], int n) {
int min = INT_MAX, min_index;
for (int v = 0; v < n; v++)
if (sptSet[v] == 0 && dist[v] <= min)
min = dist[v], min_index = v;
return min_index;
}
// 实现Dijkstra算法
void dijkstra(int graph[V][V], int src, int n) {
int dist[V]; // dist[i]表示源点到i的最短距离
int sptSet[V]; // sptSet[i]为真，如果i在最短路径集合中
// 初始化所有距离为无穷大，sptSet[]为假
for (int i = 0; i < n; i++)
dist[i] = INT_MAX, sptSet[i] = 0;
// 源点到自己的距离总是为0
dist[src] = 0;
// 找到所有顶点的最短路径
for (int count = 0; count < n - 1; count++) {
// 选择最短距离顶点的最小值
int u = minDistance(dist, sptSet, n);
// 标记这个顶点已经处理
sptSet[u] = 1;
// 更新相邻顶点的距离值
for (int v = 0; v < n; v++)
if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX &&
dist[u] + graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u][v];
}
// 打印构建的距离数组
for (int i = 0; i < n; i++)
printf("顶点 %d 到源点的最短距离是: %d\n", i, dist[i]);
}
5 字符串处理
5.1 字符串匹配
如KMP算法、Boyer-Moore算法等，使用数组来存储字符串的部分匹配信息。
5.1.1 KMP算法
KMP算法的核心思想是，当在文本字符串中从左到右进行模式匹配时，如果某个字符不匹配，那么我们可以利用之前已经匹配的部分信息，跳过一些不必要的比较，从而提高匹配效率。
void KMPSearch(char *pat, char *txt) {
int M = strlen(pat);
int N = strlen(txt);
int lps[M];
computeLPSArray(pat, M, lps);
int i = 0; // index for txt
int j = 0; // index for pat
while (i < N) {
if (pat[j] == txt[i]) {
i++;
j++;
}
if (j == M) {
printf("Found pattern at index %d\n", i - j);
j = lps[j-1];
} else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j-1];
else
i = i+1;
}
}
}
5.1.2 Boyer-Moore算法
Boyer-Moore算法是一种高效的字符串搜索算法，它通过两个关键的预处理函数来优化搜索过程：坏字符规则（Bad Character Heuristic）和好后缀规则（Good Suffix Heuristic）。以下是C语言实现Boyer-Moore算法的关键函数：
1. 坏字符规则的预处理函数：
#define NO_OF_CHARS 256
void badCharHeuristic(char* str, int size, int badchar[NO_OF_CHARS]) {
int i;
for (i = 0; i < NO_OF_CHARS; i++)
badchar[i] = -1;
for (i = 0; i < size; i++)
badchar[(int)str[i]] = i;
}
2. 搜索函数：
void search(char* txt, char* pat) {
int m = strlen(pat);
int n = strlen(txt);
int badchar[NO_OF_CHARS];
badCharHeuristic(pat, m, badchar);
int s = 0; // s is shift of the pattern with respect to text
while (s <= (n - m)) {
int j = m - 1;
while (j >= 0 && pat[j] == txt[s + j])
j--;
if (j < 0) {
printf("\n pattern occurs at shift = %d", s);
s += (s + m < n) ? m - badchar[txt[s + m]] : 1;
} else {
s += max(1, j - badchar[txt[s + j]]);
}
}
}
在这段代码中， badCharHeuristic 函数用于构建坏字符规则表，它记录了模式字符串中每个字符的最后出现位置。 search 函数则是Boyer-Moore算法的核心，它使用坏字符规则来决定模式字符串应该向右移动的距离。
要使用这些函数，你需要在主函数中调用 search 函数，并传入文本字符串和模式字符串。这样就会打印出模式字符串在文本字符串中出现的所有位置。
在Boyer-Moore算法中，"好后缀"（Good Suffix）是指在模式字符串中，当发生匹配失败时，已经成功匹配的模式字符串的后缀中最长的相同前缀和后缀的子串。这个概念用于在发生不匹配时，决定模式字符串应该向右移动的距离。
例如，假设我们有模式字符串 "ABABC" ，并且我们正在尝试在文本字符串中匹配它。如果我们在某个位置尝试匹配时， "B" 和 "C" 都匹配成功了，但下一个字符不匹配，那么 "BC" 就是一个好后缀。因为 "BC" 是模式字符串的后缀，并且它也是模式字符串的前缀。
在Boyer-Moore算法中，当发生不匹配时，算法会查找这个好后缀在模式字符串中的下一个出现位置。然后，模式字符串会移动到文本字符串中的下一个位置，使得这个好后缀与模式字符串的开始位置对齐。
例如，考虑模式字符串 "ABCDABD" ，如果我们在文本字符串中匹配时在位置 5 处发生了不匹配（即 "D" 不匹配），那么 "ABD" 就是已经匹配的子串，其中 "BD" 是一个好后缀。在模式字符串中， "BD" 也出现在开头，所以模式字符串应该移动到文本字符串中下一个 "B" 的位置，以便 "BD" 能够与模式字符串的开始位置对齐。
以下是构建好后缀规则表的C语言函数：
void goodSuffixHeuristic(char* pat, int m, int goodSuffix[NO_OF_CHARS]) {
int i, j;
for (i = 0; i < m; i++) {
goodSuffix[i] = -1;
}
for (i = 0; i < m - 1; i++) {
int len = 0;
// Check for the longest prefix which is also suffix
for (j = m - 1; j >= 0; j--) {
if (pat[j] == pat[len]) {
len++;
goodSuffix[j] = len;
} else {
break;
}
}
}
for (i = 0; i < m; i++) {
// If the value is not set then it means it is a bad character
if (goodSuffix[i] == -1)
goodSuffix[i] = m;
}
}
这个函数会填充一个数组，该数组用于存储每个字符在模式字符串中对应的好后缀长度。如果在模式字符串中没有找到相同的前缀和后缀，则该位置的值将保持为 -1 。在搜索函数中，这个数组将与坏字符规则表一起使用，以确定在发生不匹配时模式字符串应该移动的最大距离。
请注意，这个函数是一个简化的版本，它只考虑了模式字符串的前缀和后缀相等的情况。在实际应用中，可能需要更复杂的逻辑来处理不同的情况。
6 矩阵操作
6.1 矩阵乘法
计算两个矩阵的乘积。
#include <stdio.h>
#define MAX_ROWS 100
#define MAX_COLS 100
// 矩阵乘法函数
void matrixMultiply(int A[][MAX_COLS], int B[][MAX_COLS], int C[][MAX_COLS], int Arows, int Acols, int Brows, int Bcols) {
for (int i = 0; i < Arows; i++) {
for (int j = 0; j < Bcols; j++) {
C[i][j] = 0; // 初始化结果矩阵的元素为0
for (int k = 0; k < Acols; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
}
6.2 矩阵链乘
矩阵链乘问题是动态规划的经典应用之一。给定一系列矩阵，找出一种乘法顺序，使得计算所有矩阵的乘积所需的标量乘法次数最少。
假设有 A_1, A_2, ..., A_n 个矩阵需要相乘，矩阵 A_i 的维度为 p_{i-1} \times p_i。矩阵链乘问题就是要找到一种乘法顺序，使得总的标量乘法次数最小。
以下是矩阵链乘问题的关键函数，使用动态规划求解：
#include <stdio.h>
#include <limits.h>
// 动态规划解决矩阵链乘问题
void matrixChainOrder(int p[], int n, int **m, int **s) {
// 初始化m和s
for (int i = 1; i < n; i++) {
m[i][i] = 0;
}
for (int l = 2; l < n; l++) { // l是链的长度
for (int i = 1; i < n - l + 1; i++) {
int j = i + l - 1;
m[i][j] = INT_MAX;
for (int k = i; k < j; k++) {
// q = cost/scalar multiplications
int q = m[i][k] + m[k+1][j] + p[i-1] * p[k] * p[j];
if (q < m[i][j]) {
m[i][j] = q;
s[i][j] = k; // s[i][j]是分割点
}
}
}
}
}
// 打印最优乘法顺序
void printOptimalParens(int i, int j, int **s) {
if (i == j) {
printf("A%d", i);
} else {
printf("(");
printOptimalParens(i, s[i][j], s);
printOptimalParens(s[i][j] + 1, j, s);
printf(")");
}
}
// 主函数
int main() {
int arr[] = {30, 35, 15, 5, 10, 20, 25}; // 矩阵的维度
int size = sizeof(arr) / sizeof(arr[0]);
int **m = (int **)malloc(size * sizeof(int *));
int **s = (int **)malloc(size * sizeof(int *));
for (int i = 0; i < size; i++) {
m[i] = (int *)malloc(size * sizeof(int));
s[i] = (int *)malloc(size * sizeof(int));
}
matrixChainOrder(arr, size, m, s);
printf("最少的标量乘法次数是: %d\n", m[1][size - 1]);
printf("最优乘法顺序是: ");
printOptimalParens(1, size - 1, s);
printf("\n");
// 释放内存
for (int i = 0; i < size; i++) {
free(m[i]);
free(s[i]);
}
free(m);
free(s);
return 0;
}
在这个代码中， matrixChainOrder 函数计算了计算所有矩阵乘积的最小标量乘法次数，并存储在二维数组 m 中。数组 s 用于重建最优乘法顺序。
printOptimalParens 函数递归地打印出最优的乘法顺序。
在 main 函数中，我们初始化了矩阵的维度数组 arr ，分配了内存给动态数组 m 和 s ，并调用了 matrixChainOrder 函数来填充这些数组。然后，我们打印出最小的标量乘法次数和最优乘法顺序。
请注意，这段代码假设所有的矩阵都是长方形的，并且它们的相邻矩阵的维度是匹配的，即除了第一个矩阵，每个矩阵的第一个维度都应该与前一个矩阵的第二个维度相同。
7 滑动窗口
滑动窗口是一种常见的解决数组问题的方法，特别是在处理固定长度的子数组或子串时。以下是一个C语言实现的滑动窗口的关键函数示例，用于查找一个数组中最长的无重复字符的子串的长度：
#include <stdio.h>
#include <string.h>
// 函数返回最长无重复字符的子串的长度
int lengthOfLongestSubstring(char* s) {
int n = strlen(s);
int maxLength = 0;
int start = 0; // 滑动窗口的起始位置
// 用于存储字符最后出现的位置
int lastIndex[256] = {0};
for (int end = 0; end < n; end++) {
// 如果字符已经出现过，且其最后出现的位置在当前滑动窗口内
if (lastIndex[s[end]] >= start) {
start = lastIndex[s[end]] + 1;
}
// 更新字符的最后出现位置
lastIndex[s[end]] = end;
// 计算当前滑动窗口的长度，并更新最长长度
maxLength = maxLength > (end - start + 1) ? maxLength : (end - start + 1);
}
return maxLength;
}
// 主函数
int main() {
char s[] = "abcabcbb";
printf("最长无重复字符的子串的长度是: %d\n", lengthOfLongestSubstring(s));
return 0;
}
lengthOfLongestSubstring 函数用于计算字符串 s 中最长的无重复字符的子串的长度。它使用一个滑动窗口，通过 start 和 end 指针表示窗口的起始和结束位置。 lastIndex 数组用于存储每个字符最后出现的位置。
当遇到重复字符时，将窗口的起始位置 start 移动到重复字符的下一个位置。每次迭代都更新最长长度 maxLength 。
在 main 函数中，我们调用 lengthOfLongestSubstring 函数并打印出结果。
这个函数适用于查找字符串中最长的无重复字符的子串，但它可以修改用于解决其他类型的滑动窗口问题。
8 计数问题
8.1 桶排序
桶排序（Bucket Sort）是一种分布式排序算法，它将数组分为多个桶，每个桶内使用其他排序算法（如插入排序）进行排序，然后合并各个桶中的数据。桶排序的关键在于如何合理地分配桶以及如何合并桶中的数据。
以下是一个C语言实现的桶排序的关键函数示例：
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
// 函数声明
void bucketSort(float arr[], int n);
// 桶排序的关键函数
void bucketSort(float arr[], int n) {
// 创建桶
float *buckets[n]; // 桶数组
for (int i = 0; i < n; i++) {
buckets[i] = (float *)malloc(n * sizeof(float)); // 为每个桶分配内存
buckets[i][0] = 0; // 初始化桶的计数为0
}
// 将数组元素分配到各个桶中
for (int i = 0; i < n; i++) {
int idx = (int)(n * arr[i]); // 计算元素应该放入哪个桶
buckets[idx][++buckets[idx][0]] = arr[i]; // 将元素放入桶中，并更新桶的计数
}
// 对每个桶进行排序，这里使用插入排序
for (int i = 0; i < n; i++) {
int size = buckets[i][0];
for (int j = 1; j < size; j++) {
for (int k = j; k > 0 && buckets[i][k] < buckets[i][k - 1]; k--) {
float temp = buckets[i][k];
buckets[i][k] = buckets[i][k - 1];
buckets[i][k - 1] = temp;
}
}
}
// 合并桶中的数据
int idx = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < buckets[i][0]; j++) {
arr[idx++] = buckets[i][j];
}
}
// 释放桶的内存
for (int i = 0; i < n; i++) {
free(buckets[i]);
}
}
// 主函数
int main() {
float arr[] = {0.78, 0.17, 0.39, 0.26, 0.72, 0.94, 0.21, 0.12, 0.23, 0.68};
int n = sizeof(arr) / sizeof(arr[0]);
bucketSort(arr, n);
printf("排序后的数组: \n");
for (int i = 0; i < n; i++) {
printf("%0.2f ", arr[i]);
}
printf("\n");
return 0;
}
在这个示例中， bucketSort 函数接受一个浮点数数组 arr 和数组的长度 n 作为参数。它首先创建一个桶数组，并将数组元素分配到各个桶中。然后，对每个桶内的数据使用插入排序算法进行排序。最后，将所有桶中的数据合并回原数组。
在 main 函数中，我们定义了一个浮点数数组 arr ，调用 bucketSort 函数对其进行排序，并打印排序后的数组。
请注意，这个桶排序的实现假设数组的元素在 [0, 1) 区间内。如果数组的元素范围不同，可能需要调整桶的分配策略。此外，为了简化实现，每个桶的大小与原数组相同，这不是最优化的内存使用方式，但可以确保有足够的空间存储每个桶中的元素。
8.2 计数排序
对整数数组进行排序，基于元素出现的次数。
void countSort(int arr[], int n) {
int max = 0;
for (int i = 0; i < n; i++) {
if < n; i++) {
ifarrarr[i] > max) max = arr[i];
}
int count[max+1];
for (int i = 0; i <= max; i++) {
count[i] = 0;
}
for (int i = 0; i < n; i++) {
count[arr[i]]++;
}
int index = 0;
for (int i = 0; i <= max; i++) {
while (count[i] > 0) {
arr[index++] = i;
count[i]--;
}
}
}
9 前缀和
用于快速计算数组的子数组和，常用于解决区间查询问题。
void prefixSum(int arr[], int n) {
int prefix[n];
prefix[0] = arr[0];
for (int i = 1; i < n; i++) {
prefix[i] = prefix[i-1] + arr[i];
}
// prefix[i] now contains sum of arr[0...i]
}
10 堆
10.1 优先队列
使用数组实现的堆结构，可以快速获取最大或最小元素。
最大堆调整
void maxHeapify(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) {
swap(&arr[i], &arr[largest]);
maxHeapify(arr, n, largest);
}
}
11 并查集
用于处理一些不交集的合并及查询问题。
int find(int i, int parent[]) {
if (parent[i] == -1)
return i;
return find(parent[i], parent);
}
void Union(int x, int y, int parent[]) {
int xset = find(x, parent);
int yset = find(y, parent);
if(xset != yset){
parent[xset] = yset;
}
}
12 双指针
用于解决数组中的问题，如“反转字符串”、“判断回文链表”。
12.1 反转字符串
void reverseString(char* s) {
int i = 0, j = strlen(s) - 1;
while (i < j) {
char temp = s[i];
s[i] = s[j];
s[j] = temp;
i++;
j--;
}
}
数组的应用非常广泛，不同的算法根据问题的特性选择不同的数据结构和方法。数组由于其简单性和高效的随机访问特性，在算法设计中扮演着重要角色。
扫一扫
1082
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
