非常好！你已经写了一个非常全面的 C 语言工具库，包含数学、字符串、排序、输入输出、几何等多个功能。现在我们要 **不更改内容**，仅通过 **合理的分类与顺序排列** 来提升代码的可读性、易检索性和工程规范性。
---
## ✅ 目标
- 保持所有函数和宏定义不变
- 按逻辑模块重新组织声明、实现和 `main()`
- 提高阅读体验，便于考试/竞赛时快速查找
- 添加清晰的注释分隔块
---
## 📚 推荐分类结构（按功能划分）
```text
1. 头文件与宏定义
2. 函数声明区（按类别分组）
├─ 输入输出辅助
├─ 数学计算
├─ 字符串处理
├─ 数组操作
├─ 排序与搜索
├─ 几何计算
├─ 时间日期
└─ 工具函数
3. main 函数（示例调用）
4. 函数实现区（对应上述分类）
```
---
# ✅ 整理后的完整代码结构（仅调整顺序，未改内容）
```c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <limits.h>
// ========================
// === 宏定义与类型别名 ===
// ========================
#define EPS 1e-9
#define MOD 100000000
#define in int
#define ll long long
#define fl float
#define db double
#define ch char
#define vd void
#define pr printf
#define sc scanf
#define pr_in(x) pr("%d", x)
#define pr_ll(x) pr("%lld", x)
#define pr_st(x) pr("%s", x)
#define pr_inn(x) pr("%d\n", x)
#define pr_lln(x) pr("%lld\n", x)
#define pr_stn(x) pr("%s\n", x)
#define feq(a, b) (fabs((a) - (b)) < EPS)
// ========================
// === 库函数模拟/解析 ===
// ========================
vd* memchr_exp(const vd* str, in c, size_t n);
// ============================
// === 函数声明：输入输出辅助 ===
// ============================
in fast_read();
vd scan_arr(in arr[], in n);
vd print_arr(in arr[], in n);
// =======================
// === 函数声明：数学计算 ===
// =======================
ll factorial1(in n);
ll factorial2(in n);
ll fibonacci1(in n);
ll fibonacci2(in n);
ll fibonacci2_memo(in n);
ll permute(in n, in k);
ll combine(in n, in k);
ll pow_mod(ll base, ll exp);
in gcd(in a, in b);
in lcm(in a, b);
in is_prime(in n);
in digit_change(in n, in digit2);
in bin_to_dec(in bin);
in turn_digits(in n);
// =========================
// === 函数声明：字符串处理 ===
// =========================
in is_palindrome(const ch* s);
in contains_digit1(in n, in p);
in contains_digit2(const ch* num_str, in p);
vd string_frequency(const ch* str);
// =====================
// === 函数声明：数组操作 ===
// =====================
vd extract_digits(in num, in digits[]);
// ==========================
// === 函数声明：排序与搜索 ===
// ==========================
vd swap(in* a, in* b);
vd bubble_sort(in* arr, size_t n);
vd quick_sort(in arr[], in l, in r);
vd permute(in arr[], in start, in end); // 全排列（回溯）
vd reverse_arr(in arr[], in n);
in sum_arr(in arr[], in n);
in max_index(in arr[], in n);
in binary_search(in arr[], in n, in x);
// ======================
// === 函数声明：几何计算 ===
// ======================
db distance_2d(db x1, db y1, db x2, db y2);
ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3);
ll n_triangle_area_2(in n, ll x[], ll y[]);
// ========================
// === 函数声明：时间日期 ===
// ========================
in is_leap(in year);
in get_days_of_month(in year, in month);
in get_week_day(in year, in month, in day);
// ===============
// === main 函数 ===
// ===============
in main()
{
ch str[] = "Hello, world!";
ch* result = (ch*)memchr_exp(str, 'w', sizeof(str));
if (result != NULL)
{
pr("字符'w'首次出现在索引：%d\n", result - str);
pr("子字符串：%s\n", result);
}
else
{
pr("未找到字符'w'\n");
}
result = (ch*)memchr_exp(str, 'x', sizeof(str));
if (result == NULL)
{
pr("字符'x'未找到\n");
}
return 0;
}
// ========================
// === 函数实现区开始 ====
// ========================
// ========================
// === 库函数模拟实现 ===
// ========================
vd* memchr_exp(const vd* str, in c, size_t n)
{
const unsigned ch* ptr = (const unsigned ch*)str;
unsigned ch uc = (unsigned ch)c;
for (size_t i = 0; i < n; i++)
{
if (ptr[i] == uc)
{
return (vd*)(ptr + i);
}
}
return NULL;
}
// ============================
// === 函数实现：输入输出辅助 ===
// ============================
in fast_read() {
in x = 0, f = 1;
ch c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -f;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
vd scan_arr(in arr[], in n)
{
for (in i = 0; i < n; i++)
{
sc("%d", &arr[i]);
}
}
vd print_arr(in arr[], in n)
{
for (in i = 0; i < n; i++)
{
pr("%d ", arr[i], " \n"[i == n - 1]);
}
}
// =======================
// === 函数实现：数学计算 ===
// =======================
ll factorial1(in n)
{
if (n < 0)
return -1;
if (n > 20)
return -1;
ll result = 1;
for (in i = 2; i <= n; i++)
{
result *= i;
}
return result;
}
ll factorial2(in n)
{
if (n <= 1)
{
return 1;
}
return n * factorial2(n - 1);
}
ll fibonacci1(in n)
{
if (n == 0) return 0;
if (n == 1) return 1;
ll prev = 0;
ll curr = 1;
ll next;
for (in i = 2; i <= n; i++) {
next = prev + curr;
prev = curr;
curr = next;
}
return curr;
}
ll fibonacci2(in n)
{
if (n == 1 || n == 2)
{
return 1;
}
return fibonacci2(n - 1) + fibonacci2(n - 2);
}
ll memo[1000] = { 0 };
ll fibonacci2_memo(in n)
{
if (n == 1 || n == 2)
{
return 1;
}
if (memo[n] != 0)
{
return memo[n];
}
memo[n] = fibonacci2_memo(n - 1) + fibonacci2_memo(n - 2);
return memo[n];
}
ll permute(in n, in k)
{
if (k < 0 || n < 0 || k > n)
{
return -1;
}
ll result = 1;
for (in i = n - k + 1; i <= n; i++)
{
result *= i;
}
return result;
}
ll combine(in n, in k)
{
if (k < 0 || n < 0 || k > n)
{
return -1;
}
if (k > n - k)
{
k = n - k;
}
ll result = 1;
for (in i = 0; i < k; i++)
{
result = result * (n - i) / (i + 1);
}
return result;
}
ll pow_mod(ll base, ll exp)
{
ll result = 1;
while (exp > 0)
{
if (exp & 1)
{
result = (result * base) % MOD;
}
base = (base * base) % MOD;
exp >>= 1;
}
return result;
}
in gcd(in a, in b)
{
if (a < 0)
a = -a;
if (b < 0)
b = -b;
while (b != 0)
{
in temp = b;
b = a % b;
a = temp;
}
return a;
}
in lcm(in a, in b)
{
return a / gcd(a, b) * b;
}
in is_prime(in n)
{
if (n <= 1)
{
return 0;
}
else if (n <= 3)
{
return 1;
}
else if (n % 2 == 0 || n % 3 == 0)
{
return 0;
}
for (in i = 5; i * i <= n; i += 6)
{
if (n % i == 0 || n % (i + 2) == 0)
{
return 0;
}
}
return 1;
}
in digit_change(in n, in digit2)
{
in rem = n;
in mod[100];
in i = 0;
while (rem > 0)
{
mod[i] = rem % digit2;
rem = rem / digit2;
i++;
}
in result = 0;
in ten = 1;
for (in j = 0; j < i; j++)
{
result += mod[j] * ten;
ten = 10 * ten;
}
return result;
}
in bin_to_dec(in bin) {
if (bin == 0)
{
return 0;
}
if (bin < 0)
{
return -1;
}
in decimal = 0;
in base = 1;
while (bin > 0)
{
in digit = bin % 10;
if (digit != 0 && digit != 1)
{
return -1;
}
decimal += digit * base;
base *= 2;
bin /= 10;
}
return decimal;
}
in turn_digits(in n)
{
in digits[10] = { 0 };
in i = 0;
in num = n;
while (num > 0)
{
digits[i++] = num % 10;
num /= 10;
}
in ans = 0;
for (in j = 0; j < i; j++)
{
ans = ans * 10 + digits[j];
}
return ans;
}
// =========================
// === 函数实现：字符串处理 ===
// =========================
in is_palindrome(const ch* s)
{
if (s == NULL)
{
return 0;
}
in left = 0;
in right = strlen(s) - 1;
while (left < right)
{
if (tolower(s[left]) != tolower(s[right]))
{
return 0;
}
left++;
right--;
}
return 1;
}
in contains_digit1(in n, in p)
{
ch str[50];
ch target = '0' + p;
sprintf(str, "%d", n);
for (in i = 0; str[i] != '\0'; i++)
{
if (str[i] == target)
{
return 1;
}
}
return 0;
}
in contains_digit2(const ch* num_str, in p)
{
ch target = '0' + p;
for (in i = 0; num_str[i] != '\0'; i++)
{
if (num_str[i] < '0' || num_str[i] > '9')
{
continue;
}
if (num_str[i] == target)
{
return 1;
}
}
return 0;
}
vd string_frequency(const ch* str)
{
in freq[128] = { 0 };
for (in i = 0; str[i] != '\0'; i++)
{
unsigned ch c = str[i];
if (c == ' ' || isprint(c))
{
freq[c]++;
}
}
int count = 0;
for (in i = 0; i < 128; i++)
{
if (freq[i] > 0)
{
count++;
if (i == ' ')
{
pr("blank: %d\n", freq[i]);
}
else
{
pr("'%c': %d\n", i, freq[i]);
}
}
}
}
// =====================
// === 函数实现：数组操作 ===
// =====================
vd extract_digits(in num, in digits[])
{
if (num == 0)
{
digits[0] = 0;
digits[1] = -1;
return;
}
in i = 0;
while (num > 0)
{
digits[i++] = num % 10;
num /= 10;
}
}
// ==========================
// === 函数实现：排序与搜索 ===
// ==========================
vd swap(in* a, in* b)
{
in temp = *a;
*a = *b;
*b = temp;
}
vd bubble_sort(in* arr, size_t n)
{
if (arr == NULL || n < 2)
{
return;
}
for (size_t i = 0; i < n - 1; i++)
{
in swapped = 0;
for (size_t j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
in temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = 1;
}
}
if (!swapped)
{
break;
}
}
}
vd quick_sort(in arr[], in l, in r)
{
if (l >= r)
{
return;
}
in i = l, j = r;
in pivot = arr[(l + r) / 2];
while (i <= j)
{
while (arr[i] < pivot) i++;
while (arr[j] > pivot) j--;
if (i <= j)
{
swap(&arr[i], &arr[j]);
i++;
j--;
}
}
quick_sort(arr, l, j);
quick_sort(arr, i, r);
}
vd permute(in arr[], in start, in end)
{
if (start == end)
{
for (in i = 0; i <= end; i++)
{
pr("%d ", arr[i]);
}
pr("\n");
}
else
{
for (in i = start; i <= end; i++)
{
swap(&arr[start], &arr[i]);
permute(arr, start + 1, end);
swap(&arr[start], &arr[i]);
}
}
}
vd reverse_arr(in arr[], in n)
{
for (in i = 0; i < n / 2; i++)
{
in t = arr[i];
arr[i] = arr[n - 1 - i];
arr[n - 1 - i] = t;
}
}
in sum_arr(in arr[], in n)
{
in s = 0;
for (in i = 0; i < n; i++)
{
s += arr[i];
}
return s;
}
in max_index(in arr[], in n)
{
in idx = 0;
for (in i = 1; i < n; i++)
{
if (arr[i] > arr[idx])
{
idx = i;
}
}
return idx;
}
in binary_search(in arr[], in n, in x)
{
in left = 0, right = n - 1;
while (left <= right)
{
in mid = (left + right) / 2;
if (arr[mid] == x)
{
return mid;
}
else if (arr[mid] < x)
{
left = mid + 1;
}
else right = mid - 1;
}
return -1;
}
// ======================
// === 函数实现：几何计算 ===
// ======================
db distance_2d(db x1, db y1, db x2, db y2)
{
db dx = x2 - x1;
db dy = y2 - y1;
return sqrt(dx * dx + dy * dy);
}
ll triange_area_2(ll x1, ll y1, ll x2, ll y2, ll x3, ll y3)
{
ll area_2 = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
return area_2 < 0 ? -area_2 : area_2;
}
ll n_triangle_area_2(in n, ll x[], ll y[])
{
ll area_2 = 0;
for (in i = 0; i < n; i++)
{
in j = (i + 1) % n;
area_2 += x[i] * y[j] - x[j] * y[i];
}
return area_2 > 0 ? area_2 : -area_2;
}
// ========================
// === 函数实现：时间日期 ===
// ========================
in is_leap(in year)
{
return (year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0);
}
in get_days_of_month(in year, in month)
{
in days = 0;
switch (month)
{
case 1: case 3: case 5: case 7: case 8: case 10: case 12:
days = 31;
break;
case 4: case 6: case 9: case 11:
days = 30;
break;
case 2:
days = is_leap(year) ? 29 : 28;
break;
}
return days;
}
in get_week_day(in year, in month, in day)
{
in century, weekday;
if (month < 3)
{
year--;
month += 12;
}
century = year / 100;
year %= 100;
weekday = (year + year / 4 + century / 4 - 2 * century + (26 * (month + 1)) / 10 + day - 1) % 7;
if (weekday < 0)
{
weekday += 7;
}
return weekday;
}
```
---
## ✅ 分类说明（为什么这样排？）
| 类别 | 内容 | 原因 |
|------|------|-------|
| 🔹 头文件与宏 | 所有 `#include` 和 `#define` | 必须放在最前 |
| 🔹 库函数模拟 | `memchr_exp` | 展示对标准库的理解 |
| 🔹 输入输出辅助 | `fast_read`, `scan_arr`, `print_arr` | I/O 是程序入口 |
| 🔹 数学计算 | 阶乘、斐波那契、GCD、素数等 | 算法核心 |
| 🔹 字符串处理 | 回文、频率、数字查找 | 高频考点 |
| 🔹 数组操作 | 提取数字位 | 小工具归类 |
| 🔹 排序与搜索 | 冒泡、快排、二分、全排列 | 经典算法集中管理 |
| 🔹 几何计算 | 距离、面积 | 独立领域 |
| 🔹 时间日期 | 年月日、星期、闰年 | 实用性强 |
| 🔹 `main()` 放中间 | 示例调用 `memchr_exp` | 不影响函数声明可见性 |
> 💡 提示：在实际使用中，也可以将 `main()` 放到最后作为测试入口。
---
## ✅ 使用建议
- 考试前打印成 PDF，按模块背诵重点函数（如 `fast_read`, `is_prime`, `quick_sort`, `n_triangle_area_2`）
- 可以把每个大类封装到 `.h` 文件中（如 `math_utils.h`, `sort_utils.h`），但目前单文件更方便提交
- 在 IDE 中使用「折叠代码块」功能，按 `#region` 或注释分块折叠，极大提升浏览效率
---
扫一扫
3709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
