文章目录
🌈你好呀！我是 山顶风景独好
🎈欢迎踏入我的博客世界，能与您在此邂逅，真是缘分使然！😊
🌸愿您在此停留的每一刻，都沐浴在轻松愉悦的氛围中。
📖这里不仅有丰富的知识和趣味横生的内容等您来探索，更是一个自由交流的平台，期待您留下独特的思考与见解。🌟
🚀让我们一起踏上这段探索与成长的旅程，携手挖掘更多可能，共同进步！💪✨
一、求众数
题目描述：
给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数超过 ⌊ n/2 ⌋ 的元素。
示例输入：
输入：[3, 2, 3]
输出：3
输入：[2, 2, 1, 1, 1, 2, 2]
输出：2
题目分析：
众数的定义是出现次数超过一半的元素，因此我们可以利用这个特性。一个简单的方法是使用哈希表记录每个数字出现的次数，然后找到满足条件的数字。但这种方法的空间复杂度是 O(n)。我们可以使用摩尔投票算法（Boyer-Moore Voting Algorithm）来优化空间复杂度到 O(1)。
解题思路：
设定两个变量，candidate 和 count。candidate 记录当前的候选众数，count 记录这个候选众数的计数。
遍历数组：
如果 count 为 0，则将当前元素设为 candidate，count 设为 1。
如果当前元素等于 candidate，count 加 1。
如果当前元素不等于 candidate，count 减 1。
最后 candidate 就是众数，因为根据摩尔投票算法，最后剩下的 candidate 一定是出现次数超过一半的那个。
示例代码：
#include <stdio.h>
int majorityElement(int* nums, int numsSize) {
int candidate = 0;
int count = 0;
// 第一遍遍历找出候选众数
for (int i = 0; i < numsSize; i++) {
if (count == 0) {
candidate = nums[i];
count = 1;
} else if (nums[i] == candidate) {
count++;
} else {
count--;
}
}
return candidate;
}
int main() {
int nums1[] = {3, 2, 3};
int numsSize1 = sizeof(nums1) / sizeof(nums1[0]);
printf("Majority Element: %d\n", majorityElement(nums1, numsSize1));
int nums2[] = {2, 2, 1, 1, 1, 2, 2};
int numsSize2 = sizeof(nums2) / sizeof(nums2[0]);
printf("Majority Element: %d\n", majorityElement(nums2, numsSize2));
return 0;
}
深入剖析：
摩尔投票算法的关键在于，如果一个数字的出现次数超过数组长度的一半，那么遍历数组时，这个数字出现的次数与其他所有数字出现次数的差，最终一定是大于 0 的。因此，通过不断调整 candidate 和 count，最终一定能找到这个众数。
二、实现strstr函数
题目描述：
实现一个函数来查找字符串中的子串。如果找到子串，则返回子串在主串中的起始位置（从 0 开始）。如果找不到，则返回 -1。
示例输入：
输入：haystack, needle
输出：1
输入：aaaaa, bba
输出：-1
题目分析：
strstr 是一个经典的字符串匹配问题。暴力解法是遍历主串的每一个位置，然后从该位置开始比较子串，时间复杂度是 O(n*m)。我们可以使用 KMP（Knuth-Morris-Pratt）算法来优化到 O(n+m)。
解题思路：
构建部分匹配表（LPS 数组），记录子串中每个位置之前的最长公共前后缀。
使用两个指针 i 和 j 分别指向主串和子串。
如果当前字符匹配，i 和 j 同时前进。
如果不匹配，利用 LPS 数组跳过一些不必要的比较。
示例代码：
#include <stdio.h>
#include <string.h>
// 辅助函数：构建 LPS 数组
void computeLPSArray(char* pat, int M, int* lps) {
int len = 0; // 最长公共前后缀的长度
lps[0] = 0; // lps[0] 总是 0
int i = 1;
// 循环计算 lps[i] 的值
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
// KMP 字符串匹配算法
int strStr(char* haystack, char* needle) {
int N = strlen(haystack);
int M = strlen(needle);
// 特殊情况处理
if (M == 0) return 0;
if (N == 0) return -1;
int lps[M]; // 创建 LPS 数组
computeLPSArray(needle, M, lps); // 构建 LPS 数组
int i = 0; // haystack 的索引
int j = 0; // needle 的索引
while (i < N) {
if (haystack[i] == needle[j]) {
i++;
j++;
}
if (j == M) {
// 找到匹配
return i - j;
} else if (i < N && haystack[i] != needle[j]) {
if (j != 0) {
j = lps[j - 1];
} else {
i++;
}
}
}
return -1; // 未找到匹配
}
int main() {
char haystack1[] = "haystack";
char needle1[] = "needle";
printf("Index of substring: %d\n", strStr(haystack1, needle1));
char haystack2[] = "aaaaa";
char needle2[] = "bba";
printf("Index of substring: %d\n", strStr(haystack2, needle2));
return 0;
}
深入剖析：
KMP 算法的核心在于利用部分匹配表（LPS 数组）来跳过不必要的字符比较。通过预处理子串，我们可以在不匹配时快速定位下一次匹配的位置，从而大大提高了匹配效率。
三、颜色分类
题目描述：
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得红色排在前面，蓝色排在后面，白色排在中间。我们使用整数 0、1 和 2 分别表示红色、白色和蓝色。
示例输入：
输入：[2, 0, 2, 1, 1, 0]
输出：[0, 0, 1, 1, 2, 2]
输入：[1, 2, 0]
输出：[0, 1, 2]
题目分析：
这是一个典型的荷兰国旗问题，可以使用三向切分快速排序的思想解决。我们需要维护三个指针，分别指向当前遍历到的位置、0 的最右位置和 2 的最左位置。
解题思路：
初始化三个指针：low 指向最左端，mid 指向最左端，high 指向最右端。
当 mid 指针小于等于 high 指针时，执行以下操作：
如果数组 mid 位置的值为 0，交换 low 和 mid 位置的元素，并将 low 和 mid 指针都向右移动一位。
如果数组 mid 位置的值为 1，只需将 mid 指针向右移动一位。
如果数组 mid 位置的值为 2，交换 mid 和 high 位置的元素，但只将 high 指针向左移动一位（因为新交换过来的元素还未判断）。
示例代码：
#include <stdio.h>
// 函数声明：对数组中的颜色进行排序，颜色用数字0、1、2表示
void sortColors(int* nums, int numsSize);
// 主函数
int main() {
// 测试用例1
int nums1[] = {2, 0, 2, 1, 1, 0};
int numsSize1 = sizeof(nums1) / sizeof(nums1[0]);
sortColors(nums1, numsSize1);
printf("Sorted Colors: ");
for (int i = 0; i < numsSize1; i++) {
printf("%d ", nums1[i]);
}
printf("\n");
// 测试用例2
int nums2[] = {1, 2, 0};
int numsSize2 = sizeof(nums2) / sizeof(nums2[0]);
sortColors(nums2, numsSize2);
printf("Sorted Colors: ");
for (int i = 0; i < numsSize2; i++) {
printf("%d ", nums2[i]);
}
printf("\n");
return 0;
}
// 函数定义：使用三路快速排序算法对颜色进行排序
void sortColors(int* nums, int numsSize) {
int low = 0;
int mid = 0;
int high = numsSize - 1;
while (mid <= high) {
if (nums[mid] == 0) {
// 交换 low 和 mid 位置的元素
int temp = nums[low];
nums[low] = nums[mid];
nums[mid] = temp;
// 移动 low 和 mid 指针
low++;
mid++;
} else if (nums[mid] == 1) {
// 只移动 mid 指针
mid++;
} else if (nums[mid] == 2) {
// 交换 mid 和 high 位置的元素
int temp = nums[mid];
nums[mid] = nums[high];
nums[high] = temp;
// 只移动 high 指针
high--;
}
}
}
深入剖析：
荷兰国旗问题的关键在于利用三个指针来维护区间：[0, low-1] 全是 0，[low, mid-1] 全是 1，[high+1, numsSize-1] 全是 2。通过一次遍历，我们可以将数组中的元素按照要求排序，时间复杂度为 O(n)，空间复杂度为 O(1)。
✨ 这就是今天要分享给大家的全部内容了，我们下期再见！😊
🏠 我在CSDN等你哦！我的主页😍
扫一扫
702
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
