C语言面试经典问题

**C语言面试经典问题**

作为一名程序员，掌握C语言是非常重要的。以下是一些常见的C语言面试经典问题，包括一些代码示例和注释。

###1. 冒泡排序冒泡排序是一种简单的排序算法，它通过反复地交换相邻两个元素，如果前一个元素大于后一个元素，则交换它们。这样一来，最后一个元素就是最大的数。

cvoid bubbleSort(int arr[], int n) {
 for (int i =0; i < n -1; i++) {
 // 每轮比较n-i-1个数字 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;
 }
 }
 }
}

cvoid quickSort(int arr[], int low, int high) {
 if (low < high) {
 //选取基准值 int pivot = partition(arr, low, high);
 // 递归地对左边和右边进行排序 quickSort(arr, low, pivot -1);
 quickSort(arr, pivot +1, high);
 }
}

// 分区函数，返回基准值的位置int partition(int arr[], int low, int high) {
 int pivot = arr[low];
 int i = low +1;
 int j = high;
 while (i <= j) {
 // 如果左边元素小于基准值，则移动到右边 if (arr[i] < pivot) {
 i++;
 }
 // 如果右边元素大于基准值，则移动到左边 else if (arr[j] > pivot) {
 j--;
 }
 // 如果左边元素大于基准值和右边元素小于基准值，则交换它们 else {
 int temp = arr[i];
 arr[i] = arr[j];
 arr[j] = temp;
 i++;
 j--;
 }
 }
 // 将基准值移动到正确的位置 int temp = arr[low];
 arr[low] = arr[j];
 arr[j] = temp;
 return j;
}

cint binarySearch(int arr[], int n, int target) {
 int low =0;
 int high = n -1;
 while (low <= high) {
 // 计算中间索引 int mid = (low + high) /2;
 // 如果目标元素等于中间元素，则找到目标元素 if (arr[mid] == target) {
 return mid;
 }
 // 如果目标元素小于中间元素，则移动到左边 else if (arr[mid] > target) {
 high = mid -1;
 }
 // 如果目标元素大于中间元素，则移动到右边 else {
 low = mid +1;
 }
 }
 // 如果没有找到目标元素，则返回-1 return -1;
}

cint longestCommonSubsequence(char str1[], char str2[]) {
 int m = strlen(str1);
 int n = strlen(str2);
 // 创建一个二维数组来存储每个位置的最长公共子序列长度 int dp[m +1][n +1];
 for (int i =0; i <= m; i++) {
 for (int j =0; j <= n; j++) {
 // 如果两个字符串都为空，则最长公共子序列长度为0 if (i ==0 && j ==0) {
 dp[i][j] =0;
 }
 // 如果第一个字符串为空，则最长公共子序列长度等于第二个字符串的长度 else if (i ==0) {
 dp[i][j] = j;
 }
 // 如果第二个字符串为空，则最长公共子序列长度等于第一个字符串的长度 else if (j ==0) {
 dp[i][j] = i;
 }
 // 如果当前位置的字符相等，则最长公共子序列长度等于上一位置的值加1 else if (str1[i -1] == str2[j -1]) {
 dp[i][j] = dp[i -1][j -1] +1;
 }
 // 如果当前位置的字符不相等，则最长公共子序列长度等于上一位置中较大值 else {
 dp[i][j] = max(dp[i -1][j], dp[i][j -1]);
 }
 }
 }
 return dp[m][n];
}

cint minSpanningTree(int graph[][10]) {
 int n =10;
 // 创建一个二维数组来存储每个位置的最小生成树长度 int dp[n][n];
 for (int i =0; i < n; i++) {
 for (int j =0; j < n; j++) {
 // 如果两个顶点相连，则最小生成树长度等于边权值 if (i != j) {
 dp[i][j] = graph[i][j];
 }
 // 如果两个顶点不相连，则最小生成树长度为无穷大 else {
 dp[i][j] = INT_MAX;
 }
 }
 }
 for (int k =0; k < n; k++) {
 for (int i =0; i < n; i++) {
 for (int j =0; j < n; j++) {
 // 如果当前位置的值小于上一位置的值，则更新最小生成树长度 if (dp[i][j] > dp[i][k] + dp[k][j]) {
 dp[i][j] = dp[i][k] + dp[k][j];
 }
 }
 }
 }
 return dp[0][n -1];
}