第1章 C语言编程

练习1.1 编写一个程序，用两个printf()语句分别输出自己的名字和地址。

#include <stdio.h>

int main(void) {
    printf("姓名：小狮子\n");
    printf("地址：月亮之上\n");
    return 0;
}

练习1.2 将上一个练习修改成所有的输出只用一个printf()语句。

#include <stdio.h>

int main(void) {
    printf("姓名：小狮子\n地址：月亮之上\n");
    return 0;
}

练习1.3 编写一个程序，输出下列文本，格式如下所示："It's freezing in here," he said coldly.

#include <stdio.h>

int main(void) {
    printf("\"It's freezing in here,\" he said coldly.\n");
    return 0;
}

第2章 编程初步

习题2.1 编写一个程序，提示用户用英寸输入一个距离，然后将该距离值输出为码、英尺和英寸的形式。

#include <stdio.h>

/*
 * 1码=3英尺=36英寸
 */
int main()
{
    float len_inch = 0.0f;  // 英寸
    float len_foot = 0.0f;  // 英尺
    float len_yard = 0.0f;  // 码
    
    // 提示用户用英寸输入一个距离
    printf("请用英寸输入一个距离：");
    scanf("%f", &len_inch);
    
    // 计算英尺
    len_foot = len_inch / 12;
    
    // 计算码
    len_yard = len_foot / 3;
    
    // 输出计算后的结果
    printf("%.2f英寸 = %.2f英尺 = %.2f码\n", len_inch, len_foot, len_yard);
    
    return 0;
}

习题2.2 编写一个程序，提示用户用英尺和英寸输入一个房间的长和宽，然后计算并输出面积，单位是平方码，精度为小数点后两位数。

#include <stdio.h>

int main()
{
    float length_in_foot = 0.0f;    // 房间的宽度 单位英尺
    float width_in_inch = 0.0f; // 房间的宽度 单位英寸
    float area_in_yard = 0.0f;  // 房间的面积 单位平方码
    
    // 提示用户输入房间的长度
    printf("请输入房间的长度（单位：foot）：");
    scanf("%f", &length_in_foot);
    
    // 提示用户输入房间的宽度
    printf("请输入房间的宽度（单位：inch）：");
    scanf("%f", &width_in_inch);
    
    // 计算房间的面积 1码=3英尺=36英寸
    area_in_yard = (length_in_foot / 3) * (width_in_inch / 36);
    
    // 输出房间的面积
    printf("房间的面积是：%.2f平方码。\n", area_in_yard);
    
    return 0;
}

习题2.3 一个产品有两个版本：其一是标准版，价格是$3.5，其二是豪华版，价格是$5.5。编写一个程序，使用学到的知识提示用户输入产品的版本和数量，然后根据输入的产品数量，计算并输出价格。

#include <stdio.h>

int main()
{
    float price_of_normal = 3.5;    // 普通版单价
    float price_of_deluxe = 5.5f;   // 豪华版单价
    int number_of_normal = 0;    // 普通版的数量
    int number_of_deluxe = 0;   // 豪华版的数量
    float total_price = 0.0f;   // 总价
    
    // 提示用户输入产品的数量
    printf("请输入普通版的数量：");
    scanf("%d", &number_of_normal);
    printf("请输入豪华版的数量：");
    scanf("%d", &number_of_deluxe);
    
    // 计算总价
    total_price = number_of_normal * price_of_normal + number_of_deluxe + price_of_deluxe;
    
    // 输出总价
    printf("总价为：$%.2f\n", total_price);
    
    return 0;
}

习题2.4 编写一个程序，提示用户从键盘输入一个星期的薪水（以美元为单位）和工作时数，它们均为浮点数，然后计算并输出每个小时的平均时薪，输出格式如下所示：

Your average hourly pay rate is 7 dollars and 54 cents.

#include <stdio.h>

int main()
{
    float salary = 0.0f;    // 一个星期的薪水（以美元为单位）
    float hours = 0.0f; // 工作时数
    float salary_per_hour = 0.0f;   // 每个小时的平均时薪
    
    // 提示用户输入一个星期的薪水
    printf("请输入一个星期的薪水（以美元为单位）：");
    scanf("%f", &salary);
    
    // 提示用户输入工作时数
    printf("请输入工作时数：");
    scanf("%f", &hours);
    
    // 计算每个小时的平均时薪
    salary_per_hour = salary / hours;
    
    // 输出结果
    printf("Your average hourly pay rate is %d dollars and %d cents.\n", (int)salary_per_hour, (int)(salary_per_hour * 100) % 100);
    
    return 0;
}

第3章 条件判断

习题3.1 编写一个程序，首先给用户以下两种选择：

（1）将温度从摄氏度转换为华氏度。

（2）将温度从华氏度转换为摄氏度。

接着，程序提示用户输入温度值，并输出转换后的数值。从摄氏度转换为华氏度，可以乘以 1.8 再加上 32。从华氏度转换为摄氏度，可以先减去 32 后，再乘以 5，除以 9。

#include <stdio.h>
#include <ctype.h>

int main()
{
    float temperature = 0.0f;   // 用户输入的温度值
    char ch = '\0';
    float result = 0.0f;    // 转换后的温度值

    // 提示用户都有哪种转换方式
    printf("程序提供如下两种转换方式：\n");
    printf("    A. 将温度从摄氏度转换为华氏度\n    B. 将温度从华氏度转换为摄氏度\n");

    // 提示用户输入选择的转换方式
    printf("请选择转换方式（A or B）：");
    scanf("%c", &ch);

    if (tolower(ch) == 'a')
    {
        printf("请输入温度值：");
        scanf("%f",  &temperature);
        result = temperature * 1.8 + 32;
        printf("%.2f摄氏度 = %.2f华氏度\n", temperature, result);
    }
    else if (tolower(ch) == 'b')
    {
        printf("请输入温度值：");
        scanf("%f", &temperature);
        result = (temperature - 32) * 5 / 9;
        printf("%.2f华氏度 = %.2f摄氏度\n", temperature, result);
    } 
    else
    {
        printf("选择错误\n");
    }

    return 0;
}

习题3.2 编写一个程序，提示用户输入3个整数值，分别代表月、日、年。例如用户输入了12、31、2003，程序就以31st December 2003 的格式输出该日期。

必须在日期值的后面加上th、nd、st 和 rd。例如1st、2nd、3rd、4th、11th、12th、13th、14th、21st、22nd、23rd、24th。

#include <stdio.h>

int main()
{
    int year = 0;
    int month = 0;
    int day = 0;
    // 定义一个代表12个月份的枚举类型，枚举器值从1开始
    enum Month { January = 1, February, March, April, May, June, July, August, September, October, November, December };    

    // 提示用户输入月、日、年
    printf("请输入月、日、年：");
    scanf("%d%d%d", &month, &day, &year);

    // 输出日
    if (day < 1 || day > 31)
    {
        printf("输入日期有误 ");
    } 
    else if (day % 10 == 1 && day != 11)
    {
        printf("%dst ", day);
    }
    else if (day % 10 == 2 && day != 12)
    {
        printf("%dnd ", day);
    }
    else if (day % 10 == 3 && day != 13)
    {
        printf("%drd ", day);
    }
    else 
    {
        printf("%dth ", day);
    }

    // 输出月
    switch (month)
    {
    case January:
        printf("January ");
        break;
    case February:
        printf("February ");
        break;
    case March:
        printf("March ");
        break;
    case April:
        printf("April ");
        break;
    case May:
        printf("May ");
        break;
    case June:
        printf("June ");
        break;
    case July:
        printf("July ");
        break;
    case August:
        printf("August ");
        break;
    case September:
        printf("September ");
        break;
    case October:
        printf("October ");
        break;
    case November:
        printf("November ");
        break;
    case December:
        printf("December ");
        break;
    default:
        printf("输入月份有误 ");
        break;
    }

    // 输出年
    printf("%d\n", year);

    return 0;
}

习题3.3 编写一个程序，根据从键盘输入的一个数值，计算总价（单价是$5），数值超过30的折扣是10%，数值超过50的折扣是15%。

#include <stdio.h>

int main()
{
    float unit_price = 5.0f;    // 商品单价
    float discount = 0.0f;  // 商品折扣
    int number = 0; // 商品数量

    // 提示用户输入商品数量
    printf("请输入商品数量：");
    scanf("%d", &number);

    // 计算折扣
    if (number <= 30)
    {
        discount = 0.0f;
    }
    else if (number <= 50)
    {
        discount = 0.1f;
    }
    else
    {
        discount = 0.15f;
    }

    // 输出总价
    printf("商品的总价为：%.2f\n", number * unit_price * (1 - discount));

    return 0;
}

习题3.4 修改本章最后的计算器例子，让用户选择输入y或Y，以执行另一个计算，输入n或N就结束程序。（注意：这需要实用goto语句，下一章将介绍一个更好的方法。）

#include <stdio.h>

int main()
{
    double number1 = 0.0;
    double number2 = 0.0;
    char operation = 0;
    char choice = 0;

    begin:
    printf("Enter the caculation\n");
    scanf("%lf %c %lf", &number1, &operation, &number2);

    switch (operation)
    {
    case '+':
        printf("= %lf\n", number1 + number2);
        break;
    case '-':
        printf("= %lf\n", number1 - number2);
        break;
    case '*':
        printf("= %lf\n", number1 * number2);
        break;
    case '/':
        if (number2 == 0)
            printf("\n\n\aDivision by zero error!\n");
        else
            printf("= %lf\n", number1 / number2);
        break;
    case '%':
        if ((long)number1 == 0)
            printf("\n\n\aDivision by zero error!\n");
        else
            printf("= %ld\n", (long)number1 % (long)number2);
        break;
    default:
        printf("\n\n\aIllegal operation!\n");
        break;
    }

    printf("Do you want to continue? (y or n): ");
    scanf(" %c", &choice);  // 注意：%c 前面的空格不能去掉

    if (choice == 'y' || choice == 'Y')
        goto begin;

    return 0;
}

第4章 循环

习题4.1 编写一个程序，生成一个乘法表，其大小由用户输入来决定。例如，如果表的大小是4，该表就有4行4列。行和列标记为1～4.表中的每一个单元格都包含行列之积，因此第三行第4列的单元格包含12。

#include <stdio.h>

int main()
{
    int num_row = 0;
    int num_col = 0;
    
    printf("请输入行数和列数：");
    scanf("%d%d", &num_row, &num_col);
    
    printf("    ");
    for (int i = 1; i <= num_col; i++)
    {
        printf("%3d ", i);
    }
    printf("\n");
    
    for (int i = 1; i <= num_row; i++)
    {
        printf("%-4d", i);
        for (int j = 1; j <= num_col; j++)
        {
            printf("%3d ", i * j);
        }
        printf("\n");
    }
    return 0;
}

习题4.2 编写一个程序，为0～127之间的字符码输出可打印的字符。输出每个字符码和它的符号，这两个字符占一行。列要对齐（提示：可以使用在ctype.h中声明的isgraph()函数，确定哪个字符是可以打印的）。

#include <stdio.h>
#include <ctype.h>

int main()
{
    for (int i = 0; i <= 127; i++)
    {
        if (isgraph(i))
        {
            printf("%d  %c\n", i, i);
        }
    }
    return 0;
}

习题4.3 扩展上一题，给每个空白字符输出对应的名称，例如newline，space，tab等。

// 本题略

习题4.4 使用嵌套循环输出一个用星号绘制的盒子，与程序4.2类似，但是它的宽和高由用户输入。

#include <stdio.h>

int main()
{
    int height = 0;
    int width = 0;
    
    printf("请输入盒子的宽和高：");
    scanf("%d%d", &width, &height);
    
    for (int i = 1; i <= height; i++)
    {
        for (int j = 1; j <= width; j++)
        {
            if (i == 1 || i == height)
            {
                printf("*");
            }
            else
            {
                if (j == 1 || j == width)
                {
                    printf("*");
                }
                else
                {
                    printf(" ");
                }
            }
        }
        printf("\n");
    }
    return 0;
}

习题4.5 修改程序4.7的猜谜游戏，在玩家猜错数字后，可以用一个选项让玩家继续玩下去，且想玩多久就玩多久。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>

int main()
{
    int chosen = 0;
    int guess = 0;
    int limit = 20;
    char another_game = 'Y';
    
    srand(time(NULL));
    chosen = 1 + rand() % limit;
    
    printf("\nThis is a guessing game."
           "\nI have chosen a number between 1 and 20 which you must guess.\n");
    
    do
    {
        printf("\nEnter a guess: ");
        scanf("%d", &guess);
        
        if (guess == chosen)
        {
            printf("\nYou guessed it!\n");
            return 0;
        }
        
        if (guess < 1 || guess > 20)
        {
            printf("\nI said between 1 and 20.\n");
        }
        else
        {
            printf("\nSorry. %d is wrong.\n", guess);
        }
        
        printf("\nDo you want to play again(y/n)? ");
        scanf(" %c", &another_game);
    }while(toupper(another_game) == 'Y');
    return 0;
}

第5章 数组

习题5.1 编写一个程序，从键盘上读入5个double类型的值，将它们存储到一个数组中。计算每个值的倒数（值x的倒数是 1.0/x），将结果存储到另一个数组中。输出这些倒数，并计算和输出倒数的总和。

#include <stdio.h>

int main()
{
    double original[5] = { 0.0 };
    double result[5] = { 0.0 };
    double sum = 0.0;

    for (int i = 0; i < 5; i++)
    {
        printf("%d -> ", i + 1);
        scanf("%lf", &original[i]);
    }

    for (int i = 0; i < 5; i++)
    {
        result[i] = 1.0 / original[i];
    }

    for (int i = 0; i < 5; i++)
    {
        printf("result[%d] = %lf\n", i, result[i]);
        sum += result[i];
    }

    printf("sum = %lf\n", sum);

    return 0;
}

习题5.2 定义一个数组 data，它包含 100 个 double 类型的元素。编写一个循环，将以下的数值序列存储到数组的对应元素中：

1/(2*3*4) 1/(4*5*6) 1/(6*7*8) ... up to 1/(200*201*202)

编写另一个循环，计算：

data[0] - data[1] + data[2] - data[3] + ... - data[99]

将这个结果乘以 4.0，加 3.0，输出最后的结果。

#include <stdio.h>

int main()
{
    double data[100] = { 0.0 };
    double sum = 0.0;
    double result = 0.0;
    
    for (int i = 1; i <= 100; i++)
    {
        data[i - 1] = 1.0 / ((2 * i) * (2 * i + 1)*(2 * i + 2));
    }
    
    for (int i = 0; i < 100; i++)
    {
        sum += (i % 2 ? -1 : 1) * data[i];
    }
    
    result = sum * 4.0 + 3.0;
    
    printf("计算结果为：%lf\n", result);
    return 0;
}

习题5.3 编写一个程序，从键盘上读入 5 个值，将它们存储到一个 float 类型的数组 amounts 中。创建两个包含 5 个 long 元素的数组 dollars 和 cents。将 amounts 数组元素的整数部分存储到 dollars 的对应元素中，amounts 数组元素的小数部分存储到 cents 中，只保存两位数字（例如：amounts[1] 的值是 2.75，则把 2 存储到 dollars[1] 中，把 75 存储 cents[1]中）。以货币格式输出这两个 long 类型数组的值（如$2.75）。

#include <stdio.h>

int main()
{
    float amounts[5] = {0.0f};
    long dollars[5] = {0L};
    long cents[5] = {0L};
    
    for (int i = 0; i < 5; i++)
    {
        printf("%d -> ", i + 1);
        scanf("%f", &amounts[i]);
    }
    
    for (int i = 0; i < 5; i++)
    {
        dollars[i] = (long) amounts[i];
        cents[i] = (long)(amounts[i] * 100) % 100;
    }
    
    for (int i = 0; i < 5; i++)
    {
        printf("$%ld.%ld\n", dollars[i], cents[i]);
    }
    return 0;
}

习题5.4 定义一个 double 类型的二维数组 data[11][5]。用 2.0~3.0 的值初始化第一列元素（每步增加 0.1）。如果行中的第一个元素值是 x，改行的其它元素值分别是 1/x，x²，x³ 和 x⁴。输出数组中的值，每一行放在一行上，每一列要有标题。

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

int main()
{
    double data[11][5] = {0.0};
    
    for (int i = 0; i < 11; i++)
    {
        data[i][0] = (1 + 0.1 * i);
    }
    
    for (int i = 0; i < 11; i++)
    {
        data[i][1] = 1 / data[i][0];
        for (int j = 2; j < 5; j++)
        {
            data[i][j] = pow(data[i][0], i);
        }
    }
    
    printf("        ");
    for (int i = 0; i < 5; i++)
    {
        printf("   %02d   ", i + 1);
    }
    printf("\n");
    
    for (int i = 0; i < 11; i++)
    {
        printf("   %02d   ", i + 1);
        for (int j = 0; j < 5; j++)
        {
            printf(" %6.2lf ", data[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

习题5.5 编写一个程序，计算任意多个班级的学生的平均分。该程序应读取所有班级里学生的所有成绩，再计算平均值。给每个班级输出每个学生的平均分，以及班级的平均分。

#include <stdio.h>
#define CLASS_NUM 2
#define STUDENT_NUM 2
#define COURSE_NUM 2

int main()
{
    int score[CLASS_NUM][STUDENT_NUM][COURSE_NUM] = {0};
    int average_class = 0;
    int average_student = 0;
    
    for (int i = 0; i < CLASS_NUM; i++)
    {
        for (int j = 0; j < STUDENT_NUM; j++)
        {
            for (int k = 0; k < COURSE_NUM; k++)
            {
                printf("Class %02d  Student %02d  Course %02d  -> ", i, j, k);
                scanf("%d", &score[i][j][k]);
            }
        }
    }
    
    for (int i = 0; i < CLASS_NUM; i++)
    {
        average_class = 0;
        for (int j = 0; j < STUDENT_NUM; j++)
        {
            average_student = 0;
            for (int k = 0; k < COURSE_NUM; k++)
            {
                average_class += score[i][j][k];
                average_student += score[i][j][k];
            }
            printf("Class %02d Student %02d 的平均分是 %.2f\n", i, j, average_student * 1.0 / COURSE_NUM);
        }
        printf("Class %02d 的平均分是 %.2f\n", i, average_class * 1.0 / STUDENT_NUM / COURSE_NUM);
    }
    return 0;
}

第6章 字符串和文本的应用

习题6.1 编写一个程序，从键盘上读入一个小于1000的正整数，然后创建并输出一个字符串，说明该整数的值。例如，输入941，程序产生的字符串是“Nine hundred and forty one”。

#include <stdio.h>

void one2nineteen(int n)
{
    switch (n)
    {
        case 1:
            printf("one");
            break;
        case 2:
            printf("two");
            break;
        case 3:
            printf("three");
            break;
        case 4:
            printf("four");
            break;
        case 5:
            printf("five");
            break;
        case 6:
            printf("six");
            break;
        case 7:
            printf("seven");
            break;
        case 8:
            printf("eight");
            break;
        case 9:
            printf("nine");
            break;
        case 10:
            printf("ten");
            break;
        case 11:
            printf("eleven");
            break;
        case 12:
            printf("twelve");
            break;
        case 13:
            printf("thirteen");
            break;
        case 14:
            printf("fourteen");
            break;
        case 15:
            printf("fifteen");
            break;
        case 16:
            printf("sixteen");
            break;
        case 17:
            printf("seventeen");
            break;
        case 18:
            printf("eighteen");
            break;
        case 19:
            printf("nineteen");
            break;
            
        default:
            printf("one2nineteen操作失败");
            break;
    }
}

void fun(int n)
{
    switch (n) {
        case 20:
            printf("twenty");
            break;
        case 30:
            printf("thirty");
            break;
        case 40:
            printf("fourty");
            break;
        case 50:
            printf("fifty");
            break;
        case 60:
            printf("sixty");
            break;
        case 70:
            printf("seventy");
            break;
        case 80:
            printf("eighty");
            break;
        case 90:
            printf("ninety");
            break;
        default:
            printf("fun执行出错");
            break;
    }
}

void fun2(int n)
{
    if (n < 20)
    {
        one2nineteen(n);
    }
    else if (n < 100)
    {
        if (n % 10 == 0)
        {
            fun(n);
        }
        else
        {
            fun(n - n % 10);
            printf("-");
            one2nineteen(n % 10);
        }
    }
}

void int2str(int n)
{
    if (n < 100)
    {
        fun2(n);
    }
    else if (n < 1000)
    {
        if (n % 100 == 0)
        {
            one2nineteen(n / 100);
            printf(" hundred");
        }
        else
        {
            one2nineteen(n / 100);
            printf(" hundred and ");
            fun2(n % 100);
        }
    }
}

int main()
{
    for (int i = 1; i < 1000; i++)
    {
        printf("%3d -> ", i);
        int2str(i);
        printf("\n");
    }
    return 0;
}

习题6.2 编写一个程序，输入一系列单词，单词之间以逗号分割，然后提取这些单词，并将它们分行输出，删除头尾的空格。例如，如果输入是

John ， Jack ， Jill

输出将是：

John

Jack

Jill

#include <stdio.h>
#include <ctype.h>
#include <stdbool.h>

int main()
{
    char sequence[100] = { 0 };
    bool first = true;
    
    printf("请输入一系列单词，单词之间以逗号分隔：\n");
    if (fgets(sequence, sizeof(sequence), stdin) == NULL)
    {
        printf("输入过程出错\n");
        return 1;
    }
    else
    {
        for (int i = 0; i < 100 && sequence[i] != '\0'; i++)
        {
            if (isalpha(sequence[i])) {
                first = true;
                printf("%c", sequence[i]);
            }
            else
            {
                if (first)
                {
                    first = false;
                    printf("\n");
                }
            }
        }
        printf("\n");
    }
    return 0;
}

习题6.3 编写一个程序，从一组至少有5个字符串的数组里，输出任意挑选的一个字符串。

#include <stdio.h>

int main()
{
    char arr[][50] = {
        "Hello",
        "Hello World",
        "Hello World, Hello World!"
    };
    
    printf("%s\n", arr[2]);
    return 0;
}

习题6.4 回文是正读反读均相同的句子，忽略空白和标点符号。例如，“Madam, I'm Adam”和“Are we no drawn onward, we few? Drawn onward to new era?”都是回文。编写一个程序，确定从键盘输入的字符串是否是回文。

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

int main()
{
    char sequence[100] = { 0 };
    unsigned long head = 0;
    unsigned long last = 0;
    bool flag = true;
    
    printf("请输入一个字符串：\n");
    if (gets(sequence) == NULL)
    {
        printf("输入过程出错\n");
        return 1;
    }
    else
    {
        last = strlen(sequence);
        
        for (; head < last; )
        {
            for (;!isalpha(sequence[head]);)
            {
                head++;
            }
            
            for (; !isalpha(sequence[last]);)
            {
                last--;
            }
            
            if (toupper(sequence[head]) == toupper(sequence[last]))
            {
                head++;
                last--;
            }
            else
            {
                flag = false;
                break;
            }
        }
        
        if (flag)
        {
            printf("是回文\n");
        }
        else
        {
            printf("不是回文\n");
        }
    }
    return 0;
}

第7章 指针

习题7.1 编写一个程序，计算从键盘输入的任意个浮点数的平均值。将所有的数存储到动态分配的内存中，之后计算并显示平均值。用户不需要事先指定要输入多少个数。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    float number = 0.0f;
    float *pNumber = NULL;
    int count = 0;
    float sum = 0.0f;

    pNumber = (float *)malloc(sizeof(float));
    if (pNumber == NULL)
    {
        printf("内存分配失败\n");
        return 1;
    }

    do
    {
        scanf("%f", &number);
        count++;
        pNumber = realloc(pNumber, count * sizeof(float));

        *(pNumber + count - 1) = number;
    } while(number != 0.0f);

    for (int i = 0; i < count - 1; i++)
    {
        sum += *(pNumber + i);
    }

    printf("平均值是 %f\n", sum / (count - 1));

    free(pNumber);
    return 0;
}

习题7.2 编写一个程序，从键盘读入任意个谚语，并将它们存储到执行期间分配的内存中。然后，将它们以字长顺序由短到长地输出。

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

int main()
{
    char **pStr = NULL;
    char *pBuffer = NULL;
    int count = 0;

    pStr = malloc(sizeof(char *));

    do
    {
        pBuffer = malloc(100 * sizeof(char));
        gets(pBuffer);
        count++;
        pStr = realloc(pStr, count * sizeof(char *));
        *(pStr + count - 1) = pBuffer;
    }while(strlen(pBuffer) != 0);

    for (int i = 0; i < count - 2; i++)
    {
        for (int j = 0; j < count - 2 - i; j++)
        {
            if (strlen(*(pStr + j)) > strlen(*(pStr + j + 1)))
            {
                pBuffer = *(pStr + j);
                *(pStr + j) = *(pStr + j + 1);
                *(pStr + j + 1) = pBuffer;
            }
        }
    }

    for (int i = 0; i < count - 1; i++)
    {
        printf("%s\n", *(pStr + i));
    }
    return 0;
}

习题7.3 编写一个程序，从键盘读入一个字符串，显示删除了所有空格和标点符号的字符串。所有的操作都使用指针完成。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

int main()
{
    char *pStr = NULL;

    pStr = malloc(100*sizeof(char));

    gets(pStr);

    while(*pStr)
    {
        if (isalpha(*pStr))
        {
            putchar(*pStr);
        }
        pStr++;
    }

    putchar('\n');

    return 0;
}

习题7.4 编写一个程序，读入任意天数的浮点温度记录值，每天有6个记录。温度记录存储在动态分配内存的数组中，数组的大小刚好等于输入的温度数。计算出每天的平均温度，然后输出每天的记录，在单独一行上输出平均值，该平均值精确到小数点后一位。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    float **pTemp = NULL;
    float sum = 0.0f;
    int count = 0;
    
    pTemp = malloc(sizeof(float));
    
    do
    {
        count++;
        pTemp = realloc(pTemp, count * sizeof(float *));
        *(pTemp + count - 1) = malloc(6 * sizeof(float));
        
        printf("Day %d :\n", count);
        for (int i = 0; i < 6; i++)
        {
            printf("%d -> ", i + 1);
            scanf("%f", (*(pTemp + count - 1) + i));
        }
    }while(**(pTemp + count - 1) != 0.0f);
    
    for (int i = 0; i < count - 1; i++)
    {
        printf("Day %d :\n", i + 1);
        sum = 0;
        for (int j = 0; j < 6; j++)
        {
            sum += *(*(pTemp+i) + j);
            printf("%d -> %f\n", j + 1, *(*(pTemp+i) + j));
        }
        printf("average = %.1f\n", sum / 6);
    }
    return 0;
}

第8章 程序的结构

习题8.1 定义一个函数，给函数传送任意多个浮点数，计算出这些数的平均值。从键盘输入任意个值，并输出平均值，以说明这个函数的执行过程。

#include <stdio.h>
#include <stdlib.h>

float average(float *, int);

int main()
{
    float *pNum = NULL;
    int count = 0;
    pNum = malloc(count * sizeof(float));

    do
    {
        count++;
        pNum = realloc(pNum, count * sizeof(float));
        scanf("%f", pNum + count - 1);
    } while(*(pNum + count - 1) != 0.0f);

    printf("average = %f\n", average(pNum, count - 1));

    return 0;
}

float average(float *pNum, int count)
{
    float sum = 0.0f;
    for (int i = 0; i < count; i++)
    {
        sum += *(pNum + i);
    }
    return sum / count;
}

习题8.2 定义一个函数，返回其整数变元的字符串表示。例如，如果这个变元是25，函数就返回"25"。如果变元是-98，函数就返回"-98"。用适当的main()版本说明函数的执行过程。

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

char *intToString(int);

int main()
{
    printf("%s\n", intToString(-32768));
    return 0;
}

char *intToString(int number)
{
    char *pStr = malloc(7 * sizeof(char));
    int var = 10000;
    int weishu = 5;
    int count = 0;
    if (number < 0)
    {
        *(pStr + 0) = '-';
        count = 1;
        number = -number;
    }

    while (number / var == 0) {
        weishu--;
        var /= 10;
    }

    for (; count < 7; count++)
    {
        *(pStr + count) = '0' + number / (int)(pow(10, weishu - 1));
        number %= (int)(pow(10, weishu - 1));
        weishu--;
        if (weishu <= 0) {
            break;
        }
    }
    *(pStr + count + 1) = '\0';

    return pStr;
}

习题8.3 扩展为上一题定义的函数，使函数接受第二个变元，以指定结果的字段宽度，使返回的字符串表示右对齐。例如，如果第一个变元的值是-98，字段宽度变元是5，返回的字符串就应该是" -98"。用适当的main()版本说明函数的执行过程。

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

char *intToString(int, int);

int main()
{
    printf("%s\n", intToString(-98, 5));
    return 0;
}

char *intToString(int number, int width)
{
    char *pStr = malloc(7 * sizeof(char));
    int var = 10000;
    int weishu = 5;
    int count = 0;
    int len = 0;
    if (number < 0)
    {
        *(pStr + 0) = '-';
        count = 1;
        number = -number;
    }

    while (number / var == 0) {
        weishu--;
        var /= 10;
    }

    for (; count < 7; count++)
    {
        *(pStr + count) = '0' + number / (int)(pow(10, weishu - 1));
        number %= (int)(pow(10, weishu - 1));
        weishu--;
        if (weishu <= 0) {
            break;
        }
    }
    *(pStr + count + 1) = '\0';

    len = (int)strlen(pStr);
    if (len < width)
    {
        pStr = realloc(pStr, (width + 1) * sizeof(char));
        *(pStr + width) = '\0';
        int j = width - 1;
        for (int i = len; i > 0; i--, j--)
        {
            *(pStr + j) = *(pStr + i - 1);
        }
        for (;j >= 0; j--)
        {
            *(pStr + j) = ' ';
        }
    }

    return pStr;
}

习题8.4 定义一个函数，其参数是一个字符串，返回该字符串中的单词数（单词以空格或标点符号来分隔。假设字符串不包含单双引号，也就是数没有像isn't这样的单词）。定义第二个函数，它的第一个参数是一个字符串，第二个参数是一个数组，该函数将第一个字符串变元分隔成单词，把这些单词存储在第二个数组变元中，最后返回存储在数组中的单词。定义第三个函数，其参数是一个字符串，返回该字符串中的字母数。使用这些函数实现一个程序，从键盘读入含有文本的字符串，输出文本中的所有单词，输出顺序是按照单词中的字母数，由短到长。

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>

int wordCount(const char *);
void stringToArray(char *, char **);
int alphaCount(char *);

int main()
{
    char buffer[100] = "";
    char *pStr = buffer;
    char **pWord = NULL;
    char *pTemp = NULL;
    int words = 0;
    pWord = malloc(20 * sizeof(char *));
    gets(buffer);
    words = wordCount(pStr);
    stringToArray(pStr, pWord);

    for (int i = 0; i < words - 1; i++)
    {
        for (int j = 0; j < words - 1 - i; j++)
        {
            if (strlen(*(pWord + j)) > strlen(*(pWord + j + 1)))
            {
                pTemp = *(pWord + j);
                *(pWord + j) = *(pWord + j + 1);
                *(pWord + j + 1) = pTemp;
            }
        }
    }

    for (int i = 0; i < words; i++)
    {
        printf("%s\n", *(pWord + i));
    }

    return 0;
}

int wordCount(const char *pStr)
{
    int count = 0;
    bool isFirst = true;
    while (*pStr) {
        if (isalpha(*pStr)) {
            if (isFirst) {
                isFirst = false;
                count++;
            }
        }
        else
        {
            isFirst = true;
        }
        pStr++;
    }
    return count;
}

void stringToArray(char *pStr, char **pWord)
{
    char *pBuffer = malloc(20 * sizeof(char));
    int wordCount = 0;
    int i = 0;

    while (*pStr) {
        if (isalpha(*pStr))
        {
            while (isalpha(*pStr)) {
                *(pBuffer + i) = *pStr;
                i++;
                pStr++;
            }
            *(pBuffer + i) = '\0';
            *(pWord + wordCount) = pBuffer;
            wordCount++;
            pBuffer = malloc(20 * sizeof(char));
            i = 0;
        }
        else
        {
            pStr++;
        }
    }
}

int alphaCount(char *pStr)
{
    int count = 0;
    while (*pStr++) {
        count++;
    }
    return count;
}

第9章 函数再探

习题9.1 函数原型：

double power(doulbe x, int n);

会计算并返回xⁿ。因此power(5.0, 4)会计算5.0*5.0*5.0*5.0，它的结果是625.0。将power()函数实现为递归函数，再用适当的main版本演示它的操作。

#include <stdio.h>

double power(double, int);

int main()
{
    printf("power(5.0, 4) = %lf\n", power(5.0, 4));
    return 0;
}

double power(double x, int n)
{
    if (n == 1)
    {
        return x;
    }
    else
    {
        return x * power(x, n - 1);
    }
}

习题9.2 函数原型：

double add(double a, double b); // returns a + b
double subtract(double a, double b);  // returns a - b
double multiply(double a, double b);  // returns a * b
double array_op(double array[], int size, double (\*pfun) (double, double));

array_op()函数的参数是：要运算的数组、数组元素数目以及一个函数指针，该函数指针指向的函数定义了在连续几个元素上进行的操作。在实现array_op()函数时，将subtract()函数传送为第三个参数，subtract()函数会用交替符号组合这些元素。因此，对于有4个元素x1、x2、x3、x4的数组，subtract()函数会计算x1-x2+x3-x4的值。

用适当的main()版本演示这些函数的运作。

#include <stdio.h>

double add(double, double);
double subtract(double, double);
double multiply(double, double);
double array_op(double[], int, double (*) (double, double));

int main()
{
    double array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf("array_op() = %lf\n", array_op(array, 5, subtract));
    return 0;
}

double add(double a, double b)
{
    return a + b;
}

double subtract(double a, double b)
{
    return a - b;
}

double multiply(double a, double b)
{
    return a * b;
}

double array_op(double array[], int size, double (*pfun) (double, double))
{
    double sum = 0.0;
    for (int i = 0; i < size / 2; i++)
    {
        sum += subtract(array[i * 2], array[i * 2 + 1]);
    }
    if (size % 2 != 0) {
        sum += array[size - 1];
    }
    return sum;
}

习题9.3 定义一个函数，它的参数是字符串数组指针，返回一个将所有字符串合并起来的字符串指针，每个字符串都用换行符来终止。如果输入数组中的原字符串将换行符作为最后一个字符，函数就不能给字符串添加另一个换行符。编写一个程序，从键盘读入几个字符串，用这个函数输出合并后的字符串。

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

#define ARR_LEN 5
#define BUF_LEN 100

char *custom_concat(char *[]);

int main()
{
    char *pStr[ARR_LEN] = { NULL };
    for (int i = 0; i < ARR_LEN; i++)
    {
        pStr[i] = malloc(BUF_LEN * sizeof(char));
        gets(pStr[i]);
    }

    printf("%s\n", custom_concat(pStr));
    return 0;
}

char *custom_concat(char *pStr[])
{
    char *pResult = NULL;
    char *pTemp = NULL;
    int totalLen = 0;
    for (int i = 0; i < ARR_LEN; i++)
    {
        totalLen += strlen(pStr[i]);
    }
    pResult = malloc((totalLen + 1) * sizeof(char));
    pTemp = pResult;
    for (int i = 0; i < ARR_LEN; i++)
    {
        strncpy(pTemp, pStr[i], strlen(pStr[i]));
        pTemp += strlen(pStr[i]);
    }

    return pResult;
}

习题9.4 一个函数的原型是：

char *to_string(int count, double first, ...);

这个函数返回一个字符串，这个字符串含有第二及其后参数的字符串表示，每个参数都有两位小数，参数间用逗号隔开。第一个参数是从第二个参数算起的参数个数。编写一个main()函数，演示这个函数的运作。

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

char *to_string(int , double, ...);

int main()
{
    printf("%s\n", to_string(4, 1.0, 2.0, 3.0, 4.0));
    return 0;
}

char *to_string(int count, double first, ...)
{
    char *pStr = malloc(100 * sizeof(char));
    char buffer[100] = "";
    va_list parg;

    va_start(parg, first);
    sprintf(buffer, "%.2f", first);
    strcat(pStr, buffer);

    for (int i = 1; i < count; i++) {
        sprintf(buffer, ", %.2f", va_arg(parg, double));
        strcat(pStr, buffer);
    }

    va_end(parg);
    return pStr;
}

第10章 基本输入输出操作

习题10.1 编写一个程序，读入、存储以及输出下列5种类型的字符串，每个字符串占一行，字符串间不能有空格。

• 类型1：一串小写字母，后跟一个数字（如 number1）
• 类型2：两个单词，每个单词的第一个字母大写，单词间用-分隔（如Seven-Up）
• 类型3：小数（如7.35）
• 类型4：一串大小写字母以及空格（如Oliver Hardy）
• 类型5：一串除了空格及数字外的任何字符（如floating-point）

以下是这5种输入类型的例子，要分开读入这些字符串：

baby1on5Jhon-Boy3.14159Stan Laurel'Winner!'

#include <stdio.h>

int main()
{
    char str[5][100] = {""};
    for (int i = 0; i < 5; i++)
    {
        printf("%d -> ", i + 1);
        gets(str[i]);
    }

    for (int i = 0;i < 5; i++)
    {
        printf("%s", str[i]);
    }
    printf("\n");
    return 0;
}

习题10.2 编写一个程序，读入以下数值，并输出它们的和：

$3.50, $ 0.75, %9.95, %2. 50

#include <stdio.h>

int main()
{
    float number[4] = { 0.0f };
    float sum = 0.0f;
    char str[100] = "";
    int i = 0;
    for ( ; i < 99; )
    {
        str[i] = getchar();
        if (('0' <= str[i] && str[i] <= '9') || str[i] == '.')
        {
            i++;
        }
        else if (str[i] == '\n')
        {
            break;
        }
    }
    str[i] = '\0';

    sscanf(str, "%4f%4f%4f%4f", &number[0], &number[1], &number[2], &number[3]);

    for (int i = 0;i < 4; i++)
    {
        sum += number[i];
    }

    printf("average = %.2f\n", sum / 4);
    return 0;
}

习题10.3 定义一个函数，其参数是一个double类型的数组，输出该数组和数组中的元素个数。这个函数的原型如下：

void show(double array[], int array_size, int field_width);

输出的值5个一行，每个值有两位小数，字符宽度是12。在程序中使用这个函数输出从1.5到4.5的值，每次增加0.3（如：1.5、1.8、2.1、...、4.5）。

#include <stdio.h>

void show(double[], int, int);

int main()
{
    double array[] = {1.5, 1.8, 2.1, 2.4, 2.7, 3.0, 3.3, 3.6, 3.9, 4.2, 4.5};
    show(array, 11, 12);

    return 0;
}

void show(double array[], int array_size, int field_width)
{
    char buffer[10] = "";
    sprintf(buffer, "%%%d.2f", field_width);
    for (int i = 0; i < array_size; i++)
    {
        if (i % 5 == 0) {
            printf("\n");
        }
        printf(buffer, array[i]);
    }
    printf("\n");
}

习题10.4 定义一个函数，使用getchar()函数从stdin中读入一个字符串，这个字符串用特定的字符终止，这个特定的终止字符作为第二个变元传给这个函数。因此，函数的原型如下：

char *getString(char *buffer, char end_char);

返回值是一个指针，它是这个函数的第一个变元。编写一个程序，使用这个函数从键盘上读取并输出5个以冒号终止的字符串。

#include <stdio.h>

char *getString(char *, char);

int main()
{
    char buffer[5][100];
    for (int i = 0; i < 5; i++)
    {
        getString(buffer[i], ':');
    }

    for (int i = 0; i < 5; i++)
    {
        printf("%s\n", buffer[i]);
    }

    return 0;
}

char *getString(char *buffer, char end_char)
{
    char *pStr = buffer;
    char ch = '\0';
    for (;;)
    {
        ch = getchar();
        if (ch != end_char) {
            *pStr++ = ch;
        }
        else
        {
            *pStr = '\0';
            break;
        }
    }
    return buffer;
}

第11章 结构化数据

习题11.1 定义一个结构类型Length，它用码、英尺和英寸表示长度。定义一个add()函数，它相加两个Length变元，返回Length类型的总和。定义第二个函数show()，显示其Length变元的值。编写一个程序，从键盘输入任意个单位的码、英尺以及英寸的长度，使用Length类型、add()、和show()函数去汇总这些长度，并输出总长。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

struct Length
{
    int yard;
    int foot;
    int inch;
};

struct Length *add(struct Length *, struct Length *);
void show(struct Length *);

int main()
{
    struct Length *pSum = NULL;
    struct Length **pLength = NULL;
    int count = 0;
    char ch = '\0';

    pSum = malloc(sizeof(struct Length));
    pSum->yard = 0;
    pSum->foot = 0;
    pSum->inch = 0;
    pLength = (struct Length **) malloc(sizeof(struct Length *));
    do
    {
        count++;
        pLength = (struct Length **) realloc(pLength, count * sizeof(struct Length *));
        *(pLength + count - 1) = malloc(sizeof(struct Length));
        printf("请输入Length：\n");
        printf("Length.yard -> ");
        scanf("%d", &(*(pLength + count - 1))->yard);
        printf("Length.foot -> ");
        scanf("%d", &(*(pLength + count - 1))->foot);
        printf("Length.inch -> ");
        scanf("%d", &(*(pLength + count - 1))->inch);
        getchar();
        ch = getchar();
    } while(tolower(ch) == 'y');

    for (int i = 0; i < count; i++)
    {
        pSum = add(pSum, *(pLength + i));
    }

    show(pSum);
    return 0;
}

struct Length *add(struct Length *a, struct Length *b)
{
    struct Length *pLength = (struct Length *)malloc(sizeof(struct Length));

    pLength->yard = a->yard + b->yard;
    pLength->foot = a->foot + b->foot;
    pLength->inch = a->inch + b->inch;

    return pLength;
}

void show(struct Length *length)
{
    printf("yard=%d, foot=%d, inch=%d\n", length->yard, length->foot, length->inch);
}

习题11.2 定义一个结构类型，它含有一个人的姓名及电话号码。在程序中使用这个结构，输入一个或多个姓以及对应的电话号码，将输入的数据存储到一个结构数组中。程序允许输入姓氏，输出对应于该姓氏的所有电话号码，可以选择是否要输出所有的姓名及他们的电话号码。

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

struct Contacts
{
    char *name;
    int phoneCount;
    char **phone;
};

struct Contacts *newContacts();
void printContacts(struct Contacts *);

int main()
{
    struct Contacts **pContacts = NULL;
    char isContinue = '\0';
    int count = 0;
    char buffer[100] = "";

    pContacts = malloc(sizeof(struct Contacts *));
    do
    {
        count++;
        pContacts = realloc(pContacts, count * sizeof(struct Contacts *));
        *(pContacts + count - 1) = newContacts();
        printf("是否继续输入联系人信息(y/n)：");
        isContinue = getchar();
        getchar();
    } while (tolower(isContinue) == 'y');

    printf("请输入姓名：");
    gets(buffer);
    for (int i = 0; i < count; i++)
    {
        if (strcmp(buffer, (*(pContacts + i))->name) == 0) {
            printContacts(*(pContacts + i));
        }
    }

    return 0;
}

struct Contacts *newContacts()
{
    struct Contacts *pContacts = NULL;
    char buffer[100] = "";
    int count = 0;
    char isContinue = '\0';
    pContacts = malloc(sizeof(struct Contacts));

    printf("请输入姓名：");
    gets(buffer);
    pContacts->name = malloc((strlen(buffer) + 1) * sizeof(char));
    strcpy(pContacts->name, buffer);

    pContacts->phone = malloc(sizeof(char *));
    do
    {
        count++;
        pContacts->phone = realloc(pContacts->phone, count * sizeof(char *));
        printf("请输入电话号码：");
        gets(buffer);
        *(pContacts->phone + count - 1) = malloc((strlen(buffer) + 1) * sizeof(char));
        strcpy(*(pContacts->phone + count - 1), buffer);
        printf("是否继续输入电话号码(y/n)：");
        isContinue = getchar();
        getchar();
    } while(tolower(isContinue) == 'y');
    pContacts->phoneCount = count;
    return pContacts;
}

void printContacts(struct Contacts *pContacts)
{
    printf("==========\n");
    printf("name = %s\n", pContacts->name);
    for (int i = 0; i < pContacts->phoneCount; i++)
    {
        printf("phone = %s\n", *(pContacts->phone + i));
    }
    printf("==========\n");
}

习题11.3 修改上一题的程序，将数据存储到链表中，按照姓名的字母顺序由小到大排序。

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

struct Contacts
{
    char *name;
    int phoneCount;
    char **phone;
    struct Contacts *next;
};

struct Contacts *newContacts();
void printContacts(struct Contacts *);

int main()
{
    struct Contacts *pHead = NULL;
    struct Contacts *pCurrent = NULL;
    struct Contacts *p = NULL;
    struct Contacts *q = NULL;
    char isContinue = '\0';
    int count = 0;

    pHead = malloc(sizeof(struct Contacts));
    do
    {
        count++;
        pCurrent = newContacts();
        if (count == 1) {
            pHead->next = pCurrent;
        }
        else
        {
            p = pHead;
            q = pHead->next;
            while (q) {
                if (strcmp(pCurrent->name, q->name) > 0) {
                    p = q;
                    q = q->next;
                }
                else
                {
                    break;
                }
            }
            pCurrent->next = q;
            p->next = pCurrent;
        }
        printf("是否继续输入联系人信息(y/n)：");
        isContinue = getchar();
        getchar();
    } while (tolower(isContinue) == 'y');

    pCurrent = pHead;
    for (int i = 0; i < count; i++)
    {
        printContacts(pCurrent->next);
        pCurrent = pCurrent->next;
    }

    return 0;
}

struct Contacts *newContacts()
{
    struct Contacts *pContacts = NULL;
    char buffer[100] = "";
    int count = 0;
    char isContinue = '\0';
    pContacts = malloc(sizeof(struct Contacts));

    printf("请输入姓名：");
    gets(buffer);
    pContacts->name = malloc((strlen(buffer) + 1) * sizeof(char));
    strcpy(pContacts->name, buffer);

    pContacts->phone = malloc(sizeof(char *));
    do
    {
        count++;
        pContacts->phone = realloc(pContacts->phone, count * sizeof(char *));
        printf("请输入电话号码：");
        gets(buffer);
        *(pContacts->phone + count - 1) = malloc((strlen(buffer) + 1) * sizeof(char));
        strcpy(*(pContacts->phone + count - 1), buffer);
        printf("是否继续输入电话号码(y/n)：");
        isContinue = getchar();
        getchar();
    } while(tolower(isContinue) == 'y');
    pContacts->phoneCount = count;
    pContacts->next = NULL;
    return pContacts;
}

void printContacts(struct Contacts *pContacts)
{
    printf("==========\n");
    printf("name = %s\n", pContacts->name);
    for (int i = 0; i < pContacts->phoneCount; i++)
    {
        printf("phone = %s\n", *(pContacts->phone + i));
    }
    printf("==========\n");
}

习题11.4 编写一个程序，从键盘上输入一段文本，然后使用结构计算每个单词的出现次数。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>

struct WordUnit
{
    int count;
    char *word;
    struct WordUnit *next;
};

void statistics(struct WordUnit *, char *);
void printWordUnit(struct WordUnit *);

int main()
{
    char buffer[100] = "";
    char temp[10] = "";
    struct WordUnit *pHead = NULL;
    struct WordUnit *pCurrent = NULL;

    pHead = malloc(sizeof(struct WordUnit));
    pHead->next = NULL;
    gets(buffer);

    for (int i = 0, j = 0; i < strlen(buffer) && j < strlen(buffer);)
    {
        for (int i = 0; i < 10; i++)
        {
            temp[i] = '\0';
        }

        if (isalpha(buffer[i]))
        {
            for (j = i; j < strlen(buffer) && isalpha(buffer[j]); j++)
                ;

            for (int k = i; k < j; k++)
            {
                temp[k - i] = buffer[k];
            }
            statistics(pHead, temp);
            i = j;
        }
        else
        {
            i++;
        }
    }

    printWordUnit(pHead->next);

    return 0;
}

void statistics(struct WordUnit *head, char *word)
{
    bool isNewWord = true;
    struct WordUnit *p = head->next;
    struct WordUnit *q = head;
    while (p) {
        if (strcmp(p->word, word) == 0) {
            p->count++;
            isNewWord = false;
            break;
        }
        q = p;
        p = p->next;
    }
    if (isNewWord) {
        p = malloc(sizeof(struct WordUnit));
        p->count = 1;
        p->word = malloc((strlen(word) + 1) * sizeof(char));
        strcpy(p->word, word);
        q->next = p;
    }
}

void printWordUnit(struct WordUnit *p)
{
    while (p) {
        printf("%10s %2d\n", p->word, p->count);
        p = p->next;
    }
}

习题11.5 编写一个程序，读取任意多个姓名。用一个二叉树按升序输出所有的姓名，排序时先排姓氏，后排名字（例如 Ann Choosy 在 Bill Champ 的后面，在 Arthur Choosy 的前面）。

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

struct Name
{
    char *firstName;
    char *lastName;
    struct Name *leftChild;
    struct Name *rightChild;
};

struct Name *readName();
void printName(struct Name *);
void insertName(struct Name *, struct Name *);

int main()
{
    struct Name *root = NULL;
    char isContinue = '\0';
    int count = 0;
    do
    {
        if (count == 0) {
            root = readName();
        }
        else
        {
            insertName(root, readName());
        }
        count++;
        printf("是否继续输入姓名：");
        isContinue = getchar();
        getchar();
    } while(tolower(isContinue) == 'y');

    printName(root);

    return 0;
}

struct Name *readName()
{
    struct Name *p = malloc(sizeof(struct Name));
    char buffer[20] = "";
    printf("请输入姓氏：");
    gets(buffer);
    p->lastName = malloc((strlen(buffer) + 1) * sizeof(char));
    strcpy(p->lastName, buffer);
    printf("请输入名字：");
    gets(buffer);
    p->firstName = malloc((strlen(buffer) + 1) *sizeof(char));
    strcpy(p->firstName, buffer);
    p->leftChild = NULL;
    p->rightChild = NULL;

    return p;
}

void printName(struct Name *p)
{
    if (p != NULL) {
        printName(p->leftChild);
        printf("%s %s\n", p->lastName, p->firstName);
        printName(p->rightChild);
    }
    return;
}

void insertName(struct Name *root, struct Name *p)
{
    if (root != NULL) {
        if (strcmp(root->lastName, p->lastName) >= 0)
        {
            if (root->leftChild != NULL) {
                insertName(root->leftChild, p);
            }
            else{
                root->leftChild = p;
            }
        }
        else
        {
            if (root->rightChild != NULL) {
                insertName(root->rightChild, p);
            }
            else
            {
                root->rightChild = p;
            }
        }
    }
    return ;
}

第12章 处理文件

习题12.1 编写一个程序，将任意数目的字符串写入文件。字符串由键盘输入，程序不能删除这个文件，因为下一题还要使用这个文件。

#include <stdio.h>
#include <stdbool.h>

int main()
{
    char buffer[100] = "";
    const char fileName[10] = "data.txt";
    FILE *pFile = NULL;

    pFile = fopen(fileName, "a");
    if (!pFile) {
        printf("打开文件失败\n");
        return 1;
    }
    do {
        fgets(buffer, 100, stdin);
        if (buffer[0] == '\n')
        {
            break;
        }
        fputs(buffer, pFile);
    } while (true);

    fclose(pFile);
    return 0;
}

习题12.2 编写一个程序，读取上一题创建的文件。每次都以反向的顺序读取一个字符串，然后按照读取顺序将它们写入一个新文件。例如，程序读取最后一个字符串，将它写入新文件，再读取倒数第二个字符串，将它写入新文件，依次类推。

#include <stdio.h>
#include <stdbool.h>

int count(char *);

int main()
{
    char buffer[100] = "";
    char fileName[10] = "data.txt";
    char fileNameNew[10] = "data2.txt";
    FILE *pFile = NULL;
    FILE *pFileNew = NULL;

    pFile = fopen(fileName, "a");
    if (!pFile) {
        printf("打开文件失败\n");
        return 1;
    }
    do {
        fgets(buffer, 100, stdin);
        if (buffer[0] == '\n')
        {
            break;
        }
        fputs(buffer, pFile);
    } while (true);

    fclose(pFile);

    pFile = fopen(fileName, "r");
    if (!pFile) {
        printf("打开文件失败\n");
        return 1;
    }
    fclose(pFile);

    pFileNew = fopen(fileNameNew, "a");
    for (int i = count(fileName) - 1; i >= 0; i--)
    {
        pFile = fopen(fileName, "r");
        for (int j = 0; j < i; j++)
        {
            fgets(buffer, 100, pFile);
        }

        fgets(buffer, 100, pFile);
        fclose(pFile);
        fputs(buffer, pFileNew);
    }
    fclose(pFileNew);

    return 0;
}

int count(char *pName)
{
    FILE *pFile = NULL;
    pFile = fopen(pName, "r");
    int count = 0;
    char buffer[100] = "";
    while (fgets(buffer, 100, pFile)) {
        count++;
    }
    fclose(pFile);
    return count;
}

习题12.3 编写一个程序，从键盘读入姓名和电话号码，将它们写入一个文件。如果这个文件不存在，就写入一个新文件。如果文件已存在，就将它们写入该文件。这个程序需要提供列出所有数据的选项。

#include <stdio.h>

struct Contacts
{
    char name[20];
    char phone[3][15];
};

char fileName[20] = "contacts.txt";

void add();

int main()
{
    add();
    return 0;
}

void add()
{
    struct Contacts con;
    FILE *pFile = NULL;
    pFile = fopen(fileName, "a");
    printf("\n请输入姓名：");
    fgets(con.name, 20, stdin);
    for (int i = 0; i < 3; i++)
    {
        printf("请输入第 %d 个电话号码：", i + 1);
        fgets(con.phone[i], 15, stdin);
    }

    fprintf(pFile, "%20s%15s%15s%15s", con.name, con.phone[0], con.phone[1], con.phone[2]);
    fclose(pFile);
}

习题12.4 扩展上一题的程序，提取对应指定的姓名的所有电话号码。这个程序允许进一步查询，添加新的姓名和电话号码，删除已有的项。

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>

struct Contacts
{
    char name[20];
    char phone[3][15];
};

char fileName[20] = "contacts.txt";

void add();
void printContacts(struct Contacts *);
bool searchByContactsName(char *, struct Contacts *, char *);
void printAll(char *);
void deleteByContactsName(char *fileName, char *contactsName);

int main()
{
    // 此处省略了函数的调用
    return 0;
}

void add()
{
    struct Contacts con;
    FILE *pFile = NULL;
    pFile = fopen(fileName, "a");
    printf("\n请输入姓名：");
    fgets(con.name, 20, stdin);
    for (int i = 0; i < 3; i++)
    {
        printf("请输入第 %d 个电话号码：", i + 1);
        fgets(con.phone[i], 15, stdin);
    }

    fprintf(pFile, "%20s%15s%15s%15s", con.name, con.phone[0], con.phone[1], con.phone[2]);
    fclose(pFile);
}

void printContacts(struct Contacts *p)
{
    printf("姓名:%s\n\t电话1:%s\n\t电话2:%s\n\t电话3:%s\n", p->name, p->phone[0], p->phone[1], p->phone[2]);
}

void deleteByContactsName(char *fileName, char *name)
{
    FILE *pFileOld = NULL;
    FILE *pFileNew = NULL;
    struct Contacts c;
    char tempFileName[20] = "temp.txt";
    if (!searchByContactsName(fileName, &c, name))
        return;

    pFileOld = fopen(fileName, "r");
    pFileNew = fopen(tempFileName, "a");

    while(fscanf(pFileOld, "%20s%15s%15s%15s", c.name, c.phone[0], c.phone[1], c.phone[2]) != EOF)
    {
        if (strcmp(name, c.name)) {
            fprintf(pFileNew, "%20s%15s%15s%15s", c.name, c.phone[0], c.phone[1], c.phone[2]);
        }
    }

    fclose(pFileOld);
    fclose(pFileNew);

    remove(fileName);
    rename(tempFileName, fileName);
}

bool searchByContactsName(char *fileName, struct Contacts *c, char *name)
{
    FILE *pFile = fopen(fileName, "r");
    while(fscanf(pFile, "%20s%15s%15s%15s", c->name, c->phone[0], c->phone[1], c->phone[2]) != EOF)
    {
        if (strcmp(c->name, name) == 0) {
            return true;
        }
    }
    return false;

}

void printAll(char *fileName)
{
    struct Contacts c;
    FILE *pFile = NULL;
    pFile = fopen(fileName, "r");
    while(fscanf(pFile, "%20s%15s%15s%15s", c.name, c.phone[0], c.phone[1], c.phone[2]) != EOF)
    {
        printContacts(&c);
    }
    fclose(pFile);
}

第13章 支持功能

习题13.1 定义一个COMPARE(x, y)宏。如果x<y，就返回-1，如果x==y，就返回0，如果x>y就返回1.编写一个例子，说明这个宏可以正常工。这个宏会优于完成相同任务的函数码？

#include <stdio.h>

#define COMPARE(x, y) (x) > (y) ? 1 : ((x) == (y) ? 0 : -1)

int main()
{
    printf("%d\n", COMPARE(5, 3));
    return 0;
}

习题13.2 定义一个函数，返回含有当前时间的字符串，如果变元是0，它的格式就是12小时制(a.m./p.m.)，如果变元是1，它的格式就是24小时制。编写一个程序，说明这个函数可以正常工作。

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

char *getTimeString(int format);

int main()
{
    printf("%s\n%s\n", getTimeString(0), getTimeString(1));
    return 0;
}

char *getTimeString(int format)
{
    char *pStr = NULL;
    char buffer[20] = "";
    struct tm *t = NULL;
    time_t val = time(NULL);
    t = localtime(&val);
    if (format == 0) {
        sprintf(buffer, "%02d:%02d:%02d", t->tm_hour, t->tm_min, t->tm_sec);
    }
    else
    {
        sprintf(buffer, "%02d:%02d:%02d", t->tm_hour > 12 ? t->tm_hour - 12 : t->tm_hour, t->tm_min, t->tm_sec);
    }

    pStr = (char *)malloc((strlen(buffer) + 1) * sizeof(char));
    strcpy(pStr, buffer);
    return pStr;
}

习题13.3 定义一个print_value(expr)宏，在新的一行上输出 exp = result，其中result的值由expr算出。编写一个例子，说明这个宏可以正常工作。

#include <stdio.h>

#define print_value(expr) printf("exp = %d\n", expr)

int main()
{
    print_value(3 + 2);
    return 0;
}