C语言面试题（拓展）

1、字符串中获取最长无重复字符子串。

要在字符串中找到最长的无重复字符的子串，可以使用滑动窗口技术。滑动窗口通过两个指针来表示当前窗口的起始和结束位置，并且维护一个哈希表来记录字符及其最后出现的位置，以此来确保字符不重复。

以下是用C语言实现的代码：

#include <stdio.h>
#include <string.h>
​
#define MAX_CHARS 256
​
int longestUniqueSubsttr(char *str) {
    int n = strlen(str);
        int current_len = 1;  // 当前子串的长度
    int max_len = 1;      // 结果
    int prev_index;       //前一个索引
​
    int *visited = (int *)malloc(sizeof(int) * MAX_CHARS);
​
    for (int i = 0; i < MAX_CHARS; i++) {
        visited[i] = -1;
    }
​
    visited[(int)str[0]] = 0;
​
    for (int i = 1; i < n; i++) {
        prev_index = visited[(int)str[i]];
​
        if (prev_index == -1 || i - current_len > prev_index) {
            current_len++;
        } else {
            if (current_len > max_len) {
                max_len = current_len;
            }
            current_len = i - prev_index;
        }
​
        visited[(int)str[i]] = i;
    }
​
    if (current_len > max_len) {
        max_len = current_len;
    }
​
    free(visited);
​
    return max_len;
}
​
int main() {
    char str[] = "abcabcbb";
    printf("最长无重复字符子串的长度是 %d\n", longestUniqueSubsttr(str));
    return 0;
}

解释：

1. 初始化：

   • visited 数组用于存储每个字符的最后出现位置，大小为 MAX_CHARS（ASCII 字符集）。

   • 初始化 visited 数组为 -1，表示所有字符初始时都未出现过。

2. 遍历字符串：

   • 对于每个字符，检查它是否在当前窗口内已出现。

   • 使用 prev_index 保存字符上次出现的位置。

   • 如果字符未出现或者不在当前窗口内，当前窗口长度 current_len 加 1。

   • 如果字符在当前窗口内已出现，更新最大长度 max_len，并重置 current_len 为当前窗口的新长度。

3. 更新哈希表：

   • 更新当前字符在 visited 中的位置。

4. 返回结果：

   • 返回最长无重复字符子串的长度。

这个算法的时间复杂度是 O(n)，因为每个字符在最坏情况下也只会被访问两次（一次被加入窗口，一次被移出窗口），空间复杂度是 O(1)，因为 visited 数组的大小是固定的。

2、求给定数组中出现频率最高的前n个数。

为了找到给定数组中出现频率最高的前n个数，我们需要以下步骤：

1. 统计每个元素的出现次数：使用一个哈希表（可以用C语言中的结构体数组来实现）。

2. 将元素及其出现次数存储在一个结构体数组中。

3. 对结构体数组按出现次数进行排序。

4. 输出前n个频率最高的元素。

下面是完整的C语言实现代码：

#include <stdio.h>
#include <stdlib.h>
​
typedef struct {
    int value;
    int count;
} ElementCount;
​
int compare(const void *a, const void *b) {
    ElementCount *elemA = (ElementCount *)a;
    ElementCount *elemB = (ElementCount *)b;
    return elemB->count - elemA->count;
}
​
void findTopNFrequent(int arr[], int size, int n) {
    ElementCount *elementCounts = malloc(size * sizeof(ElementCount));
    int distinctElements = 0;
​
    // 初始化元素计数器
    for (int i = 0; i < size; i++) {
        elementCounts[i].value = 0;
        elementCounts[i].count = 0;
    }
​
    // 统计每个元素的出现次数
    for (int i = 0; i < size; i++) {
        int found = 0;
        for (int j = 0; j < distinctElements; j++) {
            if (elementCounts[j].value == arr[i]) {
                elementCounts[j].count++;
                found = 1;
                break;
            }
        }
        if (!found) {
            elementCounts[distinctElements].value = arr[i];
            elementCounts[distinctElements].count = 1;
            distinctElements++;
        }
    }
​
    //按照出现次数降序排序元素
    qsort(elementCounts, distinctElements, sizeof(ElementCount), compare);
​
    // 打印前n个元素
    for (int i = 0; i < n && i < distinctElements; i++) {
        printf("Element: %d, Count: %d\n", elementCounts[i].value, elementCounts[i].count);
    }
​
    free(elementCounts);
}
​
int main() {
    int arr[] = {1, 3, 1, 3, 2, 1, 4, 5, 2, 3, 3, 4, 5, 4, 4, 4, 5};
    int size = sizeof(arr) / sizeof(arr[0]);
    int n = 3;
​
    findTopNFrequent(arr, size, n);
​
    return 0;
}

解释：

1. 定义结构体 ElementCount：

   • value 存储数组元素的值。

   • count 存储该元素的出现次数。

2. 统计每个元素的出现次数：

   • 遍历数组 arr，如果 elementCounts 中已存在该元素，则增加其 count。

   • 如果不存在，则将该元素及其 count 初始化为1，并记录到 elementCounts 中。

3. 排序：

   • 使用 qsort 对 elementCounts 数组按 count 从大到小排序。

4. 输出前n个频率最高的元素：

   • 遍历排序后的 elementCounts，输出前n个元素。

5. 释放内存：

   • 释放动态分配的内存 elementCounts。

通过这种方法，我们可以有效地找到数组中出现频率最高的前n个数。

3、100只骆驼，100筐土豆，大骆驼背3筐，中骆驼背2筐，2只小骆驼背1筐，问有多少种组合，思路？

要解决这个问题，我们需要计算所有可能的组合方式，使得100只骆驼总共能运送100筐土豆。我们可以通过设立不同的变量表示不同类型骆驼的数量，然后利用这些变量设立方程来解决问题。具体思路如下：

变量定义

• ( x ) 表示大骆驼的数量（每只大骆驼可以背3筐土豆）。

• ( y ) 表示中骆驼的数量（每只中骆驼可以背2筐土豆）。

• ( z ) 表示小骆驼的数量（每2只小骆驼可以背1筐土豆，所以一只小骆驼相当于0.5筐）。

设立方程

我们有以下两个约束条件：

1. 骆驼总数为100只： [ x + y + z = 100 ]

2. 背的土豆总数为100筐： [ 3x + 2y + 0.5z = 100 ]

解方程

从第一个方程我们可以得到： [ z = 100 - x - y ]

将 ( z ) 代入第二个方程： [ 3x + 2y + 0.5(100 - x - y) = 100 ]

解简化这个方程： [ 3x + 2y + 50 - 0.5x - 0.5y = 100 ] [ 2.5x + 1.5y = 50 ] [ 5x + 3y = 100 ]

现在我们只需要解这个方程就能得到所有的可能组合。具体步骤如下：

1. 逐一尝试 ( x ) 的值从0到100之间的所有整数，判断是否有对应的 ( y ) 和 ( z ) 满足方程。

2. 确保 ( x, y, z ) 都是非负整数。

实现代码

我们可以使用简单的C语言代码来计算所有满足条件的组合。

#include <stdio.h>
​
int main() {
    int x, y, z;
    int count = 0;
​
    for (x = 0; x <= 100; x++) {
        for (y = 0; y <= 100; y++) {
            z = 100 - x - y;
            if (z >= 0 && (5 * x + 3 * y == 100)) {
                printf("大骆驼: %d, 中骆驼: %d, 小骆驼: %d\n", x, y, z);
                count++;
            }
        }
    }
​
    printf("组合的总数: %d\n", count);
​
    return 0;
}

解释代码

1. 双重循环：外部循环遍历大骆驼的数量 ( x )，内部循环遍历中骆驼的数量 ( y )。

2. 计算小骆驼的数量 ( z )：根据 ( z = 100 - x - y ) 计算。

3. 判断条件：检查 ( z ) 是否为非负整数，并且检查方程 ( 5x + 3y = 100 ) 是否成立。

4. 输出结果：如果条件满足，输出对应的 ( x, y, z ) 的值并计数。

这段代码会输出所有可能的骆驼组合，并且打印出组合的总数。