C语言编程实战：五个经典练习与优化技巧

1. C语言编程实战：五个经典练习解析

作为一名长期奋战在编程一线的开发者，我深知C语言作为计算机科学的基石语言，其重要性不言而喻。今天我将分享五个来自哈工大C语言课程的编程练习，这些题目涵盖了从基础语法到算法设计的多个层面，非常适合用来检验和提升编程能力。每个题目我都会详细解析实现思路，并分享一些实际编码中的经验技巧。

1.1 整数各位数求和

计算一个整数各位数字之和是最基础的编程练习之一，但它能很好地训练我们对循环和模运算的理解。先来看题目要求：

c复制#include <stdio.h>
int compute(int n);
int main()
{
    int n,sum;
    printf("please input a number:");
    scanf("%d",&n);
    sum=compute(n);
    printf("the result is: %d",sum);
    return 0;
}
int compute(int n){
    int sum=0;
    while(n){
        sum+=n%10;
        n/=10;
    }
    return sum;
}

这个实现有几个值得注意的技术点：

1. 循环终止条件：while(n)等价于while(n != 0)，当n被不断除以10最终变为0时循环结束
2. 取各位数字：n%10获取n的个位数，n/=10相当于去掉已经处理的个位数
3. 负数处理：当前实现对于负数会得到负数的各位和，如需绝对值需要额外处理

提示：在实际工程中，建议对输入参数进行校验，比如处理INT_MIN的情况，避免未定义行为。

1.2 股票交易最大收益算法

这道题目要求计算只允许一次买卖时的最大股票收益，是动态规划算法的经典入门题。先看实现代码：

c复制#include <stdio.h>
int maxProfit(int prices[],int n);
int main()
{
    int n,arr[128];
    printf("Please input the array size\n");
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        printf("Please input the %d-th number\n",i);
        scanf("%d",&arr[i]);
    }
    int max=maxProfit(arr,n);
    printf("the maxProfit is %d\n",max);
    return 0;
}
int maxProfit(int prices[],int n){
    int max=prices[0],min=prices[0];
    for(int i=1;i<n;i++){
        if(max<prices[i]){
            max=prices[i];
        }
        if(min>prices[i]){
            min=prices[i];
        }
    }
    return max-min;
}

这个实现存在一个逻辑错误：它简单地计算全局最大值和最小值的差，而没有考虑时间顺序（必须先买后卖）。正确的动态规划解法应该是：

c复制int maxProfit(int prices[], int n) {
    if(n <= 1) return 0;
    
    int minPrice = prices[0];
    int maxProfit = 0;
    
    for(int i = 1; i < n; i++) {
        if(prices[i] < minPrice) {
            minPrice = prices[i];
        } else if(prices[i] - minPrice > maxProfit) {
            maxProfit = prices[i] - minPrice;
        }
    }
    return maxProfit;
}

这个优化后的版本：

1. 维护一个当前遇到的最小价格
2. 计算当前价格与最小价格的差，更新最大利润
3. 时间复杂度O(n)，空间复杂度O(1)

1.3 图书信息排序

这个练习要求我们按ISBN对图书信息进行排序，涉及结构体操作和字符串比较：

c复制#include <stdio.h>
#include <string.h>
struct book{
    char name_of_book[100]; //书名
    char author[25];    //作者
    char ISBN[15];
    float price;
};
void order(struct book arr[]);
int main()
{
    struct book arr[10];
    printf("please input name_of_book author ISBN price:\n");
    for(int i=0;i<4;i++){
        scanf("%s %s %s %f",arr[i].name_of_book,arr[i].author,arr[i].ISBN,&arr[i].price);
    }
    order(arr);
    for(int i=0;i<4;i++){
        printf("%s,%s,%s,%.2f\n",arr[i].name_of_book,arr[i].author,arr[i].ISBN,arr[i].price);
    }
    return 0;
}
void order(struct book arr[]){
    for(int i=0;i<4;i++){
        for(int j=i;j<4;j++){
            if(strcmp(arr[i].ISBN,arr[j].ISBN)>0){
                struct book tmp;
                strcpy(tmp.name_of_book,arr[i].name_of_book);
                strcpy(tmp.author,arr[i].author);
                strcpy(tmp.ISBN,arr[i].ISBN);
                tmp.price=arr[i].price;

                strcpy(arr[i].name_of_book,arr[j].name_of_book);
                strcpy(arr[i].author,arr[j].author);
                strcpy(arr[i].ISBN,arr[j].ISBN);
                arr[i].price=arr[j].price;

                strcpy(arr[j].name_of_book,tmp.name_of_book);
                strcpy(arr[j].author,tmp.author);
                strcpy(arr[j].ISBN,tmp.ISBN);
                arr[j].price=tmp.price;
            }
        }
    }
}

这里有几点值得注意：

1. 结构体交换：直接交换结构体变量比逐个成员交换更高效：

   c复制struct book tmp = arr[i];
   arr[i] = arr[j];
   arr[j] = tmp;
   

2. 排序算法选择：当前使用的是选择排序，时间复杂度O(n²)。对于大量数据，建议使用qsort：

   c复制int compare(const void *a, const void *b) {
       return strcmp(((struct book*)a)->ISBN, ((struct book*)b)->ISBN);
   }
   qsort(arr, n, sizeof(struct book), compare);
   

3. 输入安全：实际应用中应该限制输入的字符串长度，避免缓冲区溢出

1.4 橙子购买问题

这个数学问题要求计算购买橙子的日均花费：

c复制#include <stdio.h>
int main()
{
    int day=1,orange=2,sum=2;
    while(orange*2<=100){
        day++;
        orange*=2;
        sum+=orange;
    }
    printf("%.2f\n",sum*0.8/day);
    return 0;
}

这个问题的关键在于理解题目描述的购买模式：

• 第一天买2个
• 之后每天买前一天的2倍
• 直到某天的购买量超过100就停止

算法分析：

1. 初始化day=1，orange=2，sum=2
2. 循环检查orange*2是否≤100
3. 每次循环增加天数，翻倍购买量，累加到总和
4. 最后计算平均花费

这个实现简洁高效，时间复杂度O(log n)。在实际应用中，我们可能还需要考虑：

• 价格和购买量使用浮点数还是整数
• 边界条件处理（如最大购买量正好是100的情况）

1.5 字符串替换

最后一个练习实现字符串中的"is"替换为"be"：

c复制#include <stdio.h>
int Convert(char b[],char a[]);
int main()
{
    char str[1000],a[3]={'i','s'};
    gets(str);
    int found=Convert(str,a);
    if(found){
        printf("%d found!\n%s\n",found,str);
    }else{
        printf("not found!\n");
    }
    return 0;
}
int Convert(char b[],char a[]){
    int i=0,count=0;
    while(b[i]!='\0'){
        if(b[i]==a[0]&&b[i+1]==a[1]){
            b[i]='b';
            b[i+1]='e';
            count++;
        }
        i++;
    }
    return count;
}

这个实现有几个需要注意的地方：

1. gets()安全问题：gets()函数不检查缓冲区大小，可能导致溢出。实际应用应该使用fgets()：

   c复制fgets(str, sizeof(str), stdin);
   

2. 替换逻辑：当前实现会修改原始字符串，如果需要保留原字符串，应该创建副本

3. 边界检查：在检查b[i+1]前应该确保不是字符串结尾

改进建议：

• 添加字符串长度参数
• 支持不同长度的查找和替换字符串
• 处理重叠替换的情况

2. C语言编程经验分享

通过这五个练习，我总结了一些C语言编程的实用经验：

2.1 结构体使用技巧

1. 初始化：结构体变量最好初始化后再使用，避免未定义行为

   c复制struct book b = {0}; // 全部成员初始化为0
   

2. 传参：大型结构体应该通过指针传递，避免拷贝开销

   c复制void print_book(const struct book *b);
   

3. 柔性数组成员：对于变长数据可以使用柔性数组

   c复制struct str {
       int len;
       char s[];
   };
   

2.2 字符串处理注意事项

1. 缓冲区安全：始终使用长度受限的函数

   c复制char buf[100];
   snprintf(buf, sizeof(buf), "format", ...);
   

2. 字符串比较：strcmp返回0表示相等，注意逻辑判断

   c复制if(strcmp(s1, s2) == 0) // 正确
   if(!strcmp(s1, s2))     // 正确但可能不直观
   

3. 字符分类：使用ctype.h中的函数判断字符类型

   c复制if(isalpha(c)) // 比直接比较范围更可移植
   

2.3 算法优化思路

1. 时间复杂度分析：理解不同算法的时间复杂度很重要
2. 空间换时间：合理使用查找表等技巧提升性能
3. 边界条件：特别注意输入为空、单个元素等边界情况

2.4 调试技巧

1. 打印调试：在关键位置打印变量值
2. 断言：使用assert验证假设

   c复制#include <assert.h>
   assert(ptr != NULL);
   

3. 调试工具：熟练使用gdb、valgrind等工具

3. 常见问题与解决方案

在实际编程练习中，经常会遇到一些典型问题，下面是我总结的一些常见问题及解决方法：

3.1 段错误(Segmentation fault)

原因：

• 访问空指针
• 访问已释放内存
• 数组越界

解决方法：

1. 使用调试器定位崩溃位置
2. 检查指针是否有效
3. 检查数组索引是否越界

3.2 内存泄漏

检测工具：

• valgrind
• AddressSanitizer

预防措施：

1. 每个malloc对应一个free
2. 使用RAII模式管理资源
3. 复杂情况下使用内存池

3.3 性能问题

分析工具：

• gprof
• perf

优化方法：

1. 减少不必要的拷贝
2. 使用更高效的数据结构
3. 优化热点代码

3.4 跨平台问题

常见问题：

• 字节序差异
• 数据类型大小不同
• 系统调用差异

解决方案：

1. 使用标准类型(int32_t等)
2. 避免依赖特定平台特性
3. 使用条件编译处理差异

4. 编程风格建议

良好的编程风格能显著提高代码质量和可维护性：

4.1 命名规范

1. 变量名使用小写加下划线：student_count
2. 常量使用全大写：MAX_SIZE
3. 函数名使用动词+名词：calculate_average

4.2 代码组织

1. 相关功能放在一起
2. 函数保持短小专注
3. 合理使用注释解释复杂逻辑

4.3 错误处理

1. 检查所有可能失败的操作
2. 提供有意义的错误信息
3. 统一错误处理策略

4.4 测试策略

1. 单元测试验证基本功能
2. 边界测试检查极端情况
3. 集成测试验证组件交互

通过这五个编程练习的详细解析，我们不仅复习了C语言的基础知识，还探讨了算法优化、调试技巧和编程风格等进阶话题。在实际开发中，这些基础技能的扎实掌握往往能起到事半功倍的效果。建议读者可以尝试扩展这些练习，比如增加错误处理、提高算法效率或者添加更多功能，以此来进一步提升编程能力。