C语言经典面试题（一）

一、Fibonacci数列

问题：计算Fibonacci（斐波那契）数列

解析：Fibonacci数列又称斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21…，即每一项都是前两项之和；可以用递归或循环的方法来实现。

代码示例：

#include <stdio.h>
//递归方法
int fib(int n) {
    if (n == 0 || n == 1) {
        return n;
    }
    return fib(n - 1) + fib(n - 2);
}
//循环方法
int fib2(int n) {
    int a = 0, b = 1, c;
    if (n == 0 || n == 1) {
        return n;
    }
    for (int i = 2; i <= n; i++) {
        c = a + b;
        a = b;
        b = c;
    }
    return c;
}
int main() 
{
    int n;
    printf("Enter number of terms: ");
    scanf("%d", &n);
    printf("Fibonacci Series: ");
    for (int i = 0; i < n; i++) {
        printf("%d+", fib(i));
    }
    printf("\n");
    return 0 ;
}

二、回文字符串

问题：判断一个字符串是否是回文串

解析：回文串是指正读和反读都一样的字符串，比如"madam"或"racecar"；可以用双指针的方法来判断一个字符串是否是回文串，即从两端向中间遍历，比较每一对字符是否相等。

代码示例：

#include <stdio.h>
#include <string.h>
//判断一个字符串是否是回文串
int is_palindrome(char *s) {
    int len = strlen(s);
    int left = 0, right = len - 1;
    while (left < right) {
        if (s[left] != s[right]) {
            return 0; //不是回文串
        }
        left++;
        right--;
    }
    return 1; //是回文串
}
int main() 
{
   char s[100];
   printf("Enter a string: ");
   scanf("%s", s);
   if (is_palindrome(s)) {
       printf("'%s' is a palindrome.\n", s);
   } else {
       printf("'%s' is not a palindrome.\n", s);
   }
   return 0 ;
}

三、二分查找

问题：实现二分查找函数

解析：二分查找是一种在有序数组中查找目标元素的高效算法，每次将数组分成两半，并比较中间元素和目标元素，如果相等则返回下标，如果不等则继续在左半部或右半部查找。

代码示例：

// 二分查找函数实现
int binarySearch(int arr[], int n, int x) {
    int low = 0, high = n - 1; // 定义低位和高位指针
    while (low <= high) { // 当低位小于等于高位时循环
        int mid = (low + high) / 2; // 计算中间位置
        if (arr[mid] == x) { // 如果中间元素等于目标元素，返回下标
            return mid;
        } else if (arr[mid] < x) { // 如果中间元素小于目标元素，将低位移动到中间位置的右边
            low = mid + 1;
        } else { // 如果中间元素大于目标元素，将高位移动到中间位置的左边
            high = mid - 1;
        }
    }
    return -1; // 如果循环结束没有找到目标元素，返回-1表示不存在
}

四、求数组中位数

问题：求两个有序数组的中位数（二分查找）

解析：中位数是指将一个集合按照大小顺序排列后，最中间的那个元素。如果集合有偶数个元素，则取最中间两个元素的平均值作为中位数。求两个有序数组的中位数可以用二分查找的方法来实现，即每次比较两个数组各自中位数的大小，然后舍弃不可能包含总体中位数的部分，直到找到总体中位数或者某个数组为空。

代码示例：

#include <stdio.h>
#include <limits.h>
#include <math.h>

//求两个有序数组的中位数
double findMedianSortedArrays(int *nums1, int nums1Size, int *nums2, int nums2Size) {
    //如果nums1的长度大于nums2的长度，交换两个数组
    if (nums1Size > nums2Size) {
        return findMedianSortedArrays(nums2, nums2Size, nums1, nums1Size);
    }
    //定义两个数组的左右边界和中位数位置
    int left = 0, right = nums1Size;
    int k = (nums1Size + nums2Size + 1) / 2;
    //二分查找
    while (left < right) {
        //计算两个数组的中位数位置
        int m1 = left + (right - left) / 2;
        int m2 = k - m1;
        //比较两个数组的中位数大小
        if (nums1[m1] < nums2[m2 - 1]) {
            //如果nums1的中位数小于nums2的中位数，舍弃nums1左半部分
            left = m1 + 1;
        } else {
            //否则，舍弃nums1右半部分
            right = m1;
        }
    }
    //找到最终的划分位置
    int m1 = left;
    int m2 = k - m1;
    //计算总体中位数
    double c1 = fmax(m1 <= 0 ? INT_MIN : nums1[m1 - 1],
                     m2 <= 0 ? INT_MIN : nums2[m2 - 1]);

    if ((nums1Size + nums2Size) % 2 == 0) {
        double c2 = fmin(m1 >= nums1Size ? INT_MAX : nums1[m1],
                         m2 >= nums2Size ? INT_MAX : nums2[m2]);
        return (c1 + c2) / 2.0;
    } else {
        return c1;
    }
}
int main()
{
    int nums1[] = {1, 1, 2, 3, 4};
    int nums2[] = {1, 5, 5, 7, 9, 9};
    int nums1Size = sizeof(nums1) / sizeof(int);
    int nums2Size = sizeof(nums2) / sizeof(int);
    double median = findMedianSortedArrays(nums1, nums1Size, nums2, nums2Size);
    printf("The median of the two sorted arrays is: %f\n", median);
    return 0 ;
}

五、冒泡排序

问题：实现冒泡排序函数

解析：冒泡排序是一种简单的排序算法，每次比较相邻的两个元素，并交换它们的位置，直到没有元素需要交换为止。

代码示例：

#include <stdio.h>
#include <string.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) { // 外层循环控制排序的趟数
        int flag = 0; // 定义一个标志变量，用来判断是否发生了交换
        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;
                flag = 1; // 标志变量置为1，表示发生了交换
            }
        }
        if (flag == 0) { // 如果一趟比较没有发生任何交换，则说明数组已经有序，可以提前结束排序
            break;
        }
    }
}

int main()
{
    int i = 0 ;
    int arr[10] = {1, 2, 5, 3, 2, 8, 9, 2, 0, 7} ;

    for(i = 0 ; i < 10; i ++)
        printf("%d\t", arr[i]);

    printf("\n") ;
    bubbleSort(arr, 10);

    for(i = 0 ; i < 10; i ++)
        printf("%d\t", arr[i]);

    printf("\n") ;
    return 0 ;
}

六、快速排序

问题：实现快速排序函数

解析：快速排序是一种基于分治思想的高效排序算法，每次选择一个基准元素，并将数组分成两部分，左边都小于等于基准元素，右边都大于等于基准元素，然后递归地对左右两部分进行快速排序。

代码示例：

// 快速排序实现
void swap(int* a, int* b) {
    // 交换两个整数的值
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准元素
    int i = low - 1; // 定义一个变量i表示小于等于基准元素区域的右边界，初始为low - 1 
    for (int j = low; j < high; j++) { // 遍历数组中除了最后一个元素以外的所有元素 
        if (arr[j] <= pivot) { // 如果当前元素小于等于基准元素，则将其放入小于等于区域，并更新i和j 
            i++;
            swap(&arr[i], &arr[j]); 
        }
    }
    swap(&arr[i + 1], &arr[high]); // 将最后一个元素即基准元素放入正确位置，并返回其下标 
    return i + 1;
}

void quickSort(int arr[], int low, int high) {
    if (low < high) { // 如果低位小于高位，则说明数组有至少两个元素需要排序
        int pivot = partition(arr, low, high); // 调用partition函数将数组分成两部分，并返回基准元素所在位置
        quickSort(arr, low, pivot - 1); // 对左半部进行快速排序
        quickSort(arr, pivot + 1, high); // 对右半部进行快速排序
    }
}

七、链表反转

问题：实现单链表反转

解析：链表反转是一种常见的链表操作，将一个单向链表的所有节点的指针方向反转，使得原来的头节点变成尾节点，原来的尾节点变成头节点。

代码示例：

struct ListNode { // 定义链表节点结构体
    int val; // 节点存储的数据
    struct ListNode *next; // 节点指向的下一个节点
};

struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode *prev = NULL; // 定义一个前驱节点指针，初始为NULL
    struct ListNode *curr = head; // 定义一个当前节点指针，初始为头节点
    while (curr != NULL) { // 当当前节点不为空时循环
        struct ListNode *next = curr->next; // 保存当前节点的下一个节点
        curr->next = prev; // 将当前节点的指针反向指向前驱节点
        prev = curr; // 将前驱节点更新为当前节点
        curr = next; // 将当前节点更新为下一个节点
    }
    return prev; // 返回新的头节点，即原来的尾节点
}

八、哈希遍历

问题：数组中出现次数超过一半的元素

解析：给定一个长度为n的数组，找出其中出现次数超过n/2的元素，如果不存在则返回-1；一个简单的方法是使用哈希表来统计每个元素出现的次数，然后遍历哈希表找出最大值，并判断是否超过n/2。

代码示例：

int majorityElement(int arr[], int n) {
#define MAX 100 // 假设数组中元素不超过100

    int hash[MAX] = {0}; // 定义一个大小为MAX的数组作为哈希表，初始化为0
    for (int i = 0; i < n; i++) { // 遍历数组中的每个元素
        hash[arr[i]]++; // 将对应位置的计数加一
    }
    int max = 0; // 定义一个变量max表示最大值，初始为0
    int ans = -1; // 定义一个变量ans表示答案，初始为-1
    for (int i = 0; i < MAX; i++) { // 遍历哈希表中的每个位置
        if (hash[i] > max) { // 如果当前位置的计数大于max，则更新max和ans
            max = hash[i];
            ans = i;
        }
    }
    if (max > n / 2) { // 如果max大于n/2，则返回ans
        return ans;
    } else { // 否则返回-1表示不存在
        return -1;
    }
}

九、递归实现阶乘

问题：使用递归方法实现阶乘函数

解析：阶乘是指一个正整数的所有小于等于它的正整数的乘积，例如5! = 5 * 4 * 3 * 2 * 1 = 120；计算阶乘的一个简单方法是使用递归函数，如果n等于0或1则返回1，否则返回n乘以n - 1的阶乘。

代码示例：

#include <stdio.h>

int factorial(int n) {
    if (n == 0 || n == 1) { // 如果n等于0或1，则返回1
        return 1;
    }
    return n * factorial(n - 1); // 否则返回n乘以n - 1的阶乘
}

int main()
{
    printf("factorial(5)=%d\n", factorial(5)) ;
    printf("factorial(10)=%d\n", factorial(10)) ;
    return 0 ;
}

十、字符串翻转

问题：将一个字符串中的字符顺序颠倒

解析：翻转字符串是指将一个字符串中的字符顺序颠倒，例如"hello"翻转后为"olleh"；翻转字符串的一个简单方法是使用双指针，分别指向字符串的首尾，并交换两个指针所指向的字符，然后将两个指针向中间移动，直到相遇或者交叉为止。

代码示例：

#include <stdio.h>
#include <string.h>

void reverseString(char* str) {
    if(!str)
        return ;    //检查字符串是否有效，无效直接返回
    int len = strlen(str); // 获取字符串长度
    int left = 0; // 定义一个变量left表示左指针，初始为0
    int right = len - 1; // 定义一个变量right表示右指针，初始为len - 1
    while (left < right) { // 当左指针小于右指针时循环
        char temp = str[left]; // 将左指针所指向的字符暂存到temp中
        str[left] = str[right]; // 将右指针所指向的字符赋值给左指针所在位置
        str[right] = temp; // 将temp中暂存的字符赋值给右指针所在位置
        left++; // 左指针向右移动一位
        right--; // 右指针向左移动一位
    }
}

int main()
{
    char str[100] = "hello world" ;
    reverseString(str);
    printf("%s\n", str) ;
    return 0 ;
}