经典算法_结构体

结构体_字节对齐

结构体变量占据的内存单元的个数应当大于等于其内部所有数据成员占据内存单元数的和。

1、C语言引入了字节对齐机制，一般来说，不同的编译器字节对齐机制有所不同，但还是有以下3条通用准则：

（1）结构体变量的大小能够被其最宽基本类型成员的大小所整除；

（2）结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；

（3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

2、说明： 字节对齐第3条准则提及最宽基本类型的概念，所谓基本类型是指像char、short、int、float、double这样的内置数据类型。“数据宽度”就是指其sizeof的大小。诸如结构体、共用体和数组等都不是基本数据类型

 

#define _CRT_SECURE_NO_WARNINGS

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

//结构体字节对齐机制
//
//结构体变量占据的内存单元的个数应当大于等于其内部所有数据成员占据内存单元数的和。
//
//1、C语言引入了字节对齐机制，一般来说，不同的编译器字节对齐机制有所不同，但还是有以下3条通用准则：
//
//（1）结构体变量的大小能够被其最宽基本类型成员的大小所整除；
//
//（2）结构体每个成员相对于结构体首地址的偏移量（offset）都是最宽基本类型成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；
//
//（3）结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。
//
//2、说明： 字节对齐第3条准则提及最宽基本类型的概念，所谓基本类型是指像char、short、int、float、double这样的内置数据类型。
//“数据宽度”就是指其sizeof的大小。诸如结构体、共用体和数组等都不是基本数据类型

struct info//4
{
    int num;//4
};

struct info1//8
{
    int num;//4    4
    char c;//1    4
};

struct info2//12
{
    char c;//1    4
    int num;//4    4
    char c1;//1    4
};

struct info3//5
{
    char c;//1
    char ch[4];//4
};

struct info4//10
{
    char c;//1
    char ch[9];//9
};

struct info5//14
{
    char c;//1    2
    short sh;//2    2
    char ch[9];//9    10
};

struct info6//20
{
    char c;//1    4
    int i;//4    4
    char ch[9];//9    12
};

struct info7//11
{
    char c;//1
    char c1;//1
    char ch[9];//9
};

struct info8//32
{
    char c;//1    8
    double db;//8    8
    char ch[9];//9    16
};

struct info9//32
{
    short sh;//2    8
    double db;//8    8
    char ch[9];//9    16
};

struct info10//22
{
    short sh;//2    2
    char c;//1    char类型一样，不用相加
    char ch[19];//19    20
};

struct info11//28
{
    short sh;//2    4
    int i;//4    4
    char ch[19];//19    20
};

main()
{
    printf("sizeof(char)=%d
", sizeof(char));//1
    printf("sizeof(short)=%d
", sizeof(short));//2
    printf("sizeof(float)=%d
", sizeof(float));//4
    printf("sizeof(int)=%d
", sizeof(int));//4
    printf("sizeof(long)=%d
", sizeof(long));//4
    printf("sizeof(double)=%d
", sizeof(double));//8
    printf("
");

    printf("sizeof(struct info)=%d
", sizeof(struct info));//4

    printf("sizeof(struct info1)=%d
", sizeof(struct info1));//8

    printf("sizeof(struct info2)=%d
", sizeof(struct info2));//12

    printf("sizeof(struct info3)=%d
", sizeof(struct info3));//5

    printf("sizeof(struct info4)=%d
", sizeof(struct info4));//10

    printf("sizeof(struct info5)=%d
", sizeof(struct info5));//14

    printf("sizeof(struct info6)=%d
", sizeof(struct info6));//20

    printf("sizeof(struct info7)=%d
", sizeof(struct info7));//11

    printf("sizeof(struct info8)=%d
", sizeof(struct info8));//32

    printf("sizeof(struct info9)=%d
", sizeof(struct info9));//32

    printf("sizeof(struct info10)=%d
", sizeof(struct info10));//22

    printf("sizeof(struct info11)=%d
", sizeof(struct info11));//28

    system("pause");
}

1 动态结构体

#define _CRT_SECURE_NO_WARNINGS

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

struct dangdang
{
    char email[30];
    char name[30];
    char addr[100];
    int num;
    int bignum;
    char tel[20];
    char phone[20];
    double rmb;
};

main()
{
    struct dangdang *p = (struct dangdang *)malloc(sizeof(struct dangdang) * 10);
    int i;
    struct dangdang *px;

    for (i = 0;i < 10;i++)//下标循环
    {
        sprintf(p[i].email, "123@qq.com");
        p[i].num = 100;
        printf("%s,%d
", p[i].email, p[i].num);
    }
    
    for (px = p;px < p + 10;px++)//指针循环px->email
    {
        sprintf(px->email, "123@qq.com");
        px->num = 100;
        printf("%s,%d
", px->email, px->num);
    }

    for (i = 0;i < 10;i++)//指针循环(*(p + i)).email
    {
        sprintf((*(p + i)).email, "123@qq.com");
        (*(p + i)).num = 100;
        printf("%s,%d
", (*(p + i)).email, (*(p + i)).num);
    }

    system("pause");
};

1 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序打印出链表中第1,3,5,7...结点。

2 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将大于平均成绩的各个结点打印出来。

3 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将成绩最高的结点作为链表的第一个结点,成绩最低的结点作为尾结点。

4 建立一个链表,每个结点包括:学号、姓名、性别、年龄。输入一个年龄,如果链表中的结点所包含的年龄等于此年龄,则将此结点删去。

5 逆序输出的数列

题目内容：

你的程序会读入一系列的正整数，预先不知道正整数的数量，一旦读到-1，就表示输入结束。然后，按照和输入相反的顺序输出所读到的数字，不包括最后标识结束的-1。

输入格式:

一系列正整数，输入-1表示结束，-1不是输入的数据的一部分。

输出格式：

按照与输入相反的顺序输出所有的整数，每个整数后面跟一个空格以与后面的整数区分，最后的整数后面也有空格。

输入样例：

1 2 3 4 -1

输出样例：

4 3 2 1

时间限制：2000ms内存限制：128000kb

6 插入排序。许多玩牌的人是以这样的方式来对他们手中的牌进行排序的：设手中原有3张牌已排好序，抓1张新牌，若这张新牌的次序在原来的第2张牌之后，第3张牌之前，那么就把这张新牌放在第3张牌的位置上，原来的第3张改为第4张， 然后再抓新牌。按着这个算法，编写一个排序程序。

注：开始一张牌也没有，从第一张牌开始抓起。

7 有两个链表ａ和ｂ。设结点中包含学号、姓名。从ａ链表中删除与ｂ链表中有相同学号的那些结点。

8 建立一个链表，每个结点包括的成员为：职工号、工资。用new函数开辟新结点。要求链表包括５个结点，从键盘输入结点中的有效数据。然后把这些结点的数据打印出来。要求用函数creat来建立链表,用list函数来输出数据。这５个职工的职工号是101,103,105,107,109。

在上题的基础上，新增加一个职工数据。这个新结点不放在最后，而是按职工号顺序插入，新职工号为106。写一函数insert来插入结点。

在上两题的基础上，写一函数，用来删除一个结点（按指定职工号删除）。

9 建立两个链表，来表示x幂的两个多项式，链表中的结点有三个字段coef、exp和next，分别表示多项式每项的系数、x的指数及指向下一项的指针。编一程序，按ｘ的降幂输入多项式的系数和指数，建立两个链表，然后编一函数来完成把两个多项式的链表叠加到第三个链表中。例如:

第一个多项式为: -4x8 +5x6 +3x4 -4x的链表为:

-4 8 5 6 3 4 -4 1

第二个多项式为: 5x9 -5x8 -3x4 +7x的链表为:

5 9 -5 8 -3 4 7 1

结果的多项式为: 5x9 -9x8 +5x6 +3x

5 9 -9 8 5 6 3 1

1 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序打印出链表中第1,3,5,7...结点。

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

struct student
{
    int num;//学号
    int score;//成绩
    struct student *next;//下一个结点
};

typedef struct student STU;//简写

//涉及5个函数
STU *nit();//创建头指针，不存放数据
void add(STU *head, int num, int score);//插入数据到尾部
void Print(STU *head);//打印，递归
void PrintJi(STU *head);//打印奇数结点，非递归
void PrintOu(STU *head);//打印偶数结点，非递归

void main()
{
    STU *head = nit();//创建头指针，不存放数据

    add(head, 1, 10);//插入数据到尾部
    add(head, 2, 1);
    add(head, 3, 13);
    add(head, 4, 15);
    add(head, 5, 16);
    add(head, 6, 12);
    add(head, 7, 17);

    printf("打印，递归
");
    Print(head);//打印，递归

    printf("打印奇数结点，非递归
");
    PrintJi(head);//打印奇数结点，非递归

    printf("打印偶数结点，非递归
");
    PrintOu(head);//打印偶数结点，非递归

    system("pause");
}

STU *nit()//创建头指针，不存放数据
{
    STU *head = (STU*)malloc(sizeof(STU));//创建头结点
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(STU *head, int num, int score)//插入数据到尾部
{
    STU *new = (STU*)malloc(sizeof(STU));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//学号
    new->score = score;//成绩
    new->next = NULL;//最后指向NULL

    STU *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }
    
    p->next = new;//第3步，指针p指向指针new
}

void Print(STU *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("num=%d,score=%d
", head->next->num, head->next->score);
        Print(head->next);//递归
    }
}

void PrintJi(STU *head)//打印奇数结点，非递归
{
    STU *p = head;//指向头指针
    while (p != NULL && p->next != NULL)
    {
        printf("num=%d,score=%d
", p->next->num, p->next->score);
        p = p->next->next;//指向下一个的下一个
    }
}

void PrintOu(STU *head)//打印偶数结点，非递归
{
    STU *p = head->next;//指向头指针的下一个
    while (p != NULL && p->next != NULL)
    {
        printf("num=%d,score=%d
", p->next->num, p->next->score);
        p = p->next->next;//指向下一个的下一个
    }
}

 

2 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将大于平均成绩的各个结点打印出来。

#include <stdio.h>
#include <stdlib.h>
#define N 7

struct student
{
    int num;//学号
    int score;//成绩
    struct student *next;//下一个结点
};

typedef struct student STU;//简写

//涉及6个函数
STU *init();//创建头指针，不存放数据
void add(STU *head, int num, int score);//插入数据到尾部
void print(STU *head);//打印，递归
int Sum(STU *head);//计算总分
double Average(int sum, int n);//计算平均成绩
void PrintUpAverage(STU *head, double average);//打印大于平均成绩的各个结点

void main()
{
    int sum = 0;
    double average = 1.0;

    STU *head = init();//创建头指针，不存放数据

    add(head, 1, 10);//插入数据到尾部
    add(head, 2, 1);
    add(head, 3, 13);
    add(head, 4, 15);
    add(head, 5, 16);
    add(head, 6, 12);
    add(head, 7, 17);

    printf("打印，递归
");
    print(head);//打印，递归

    printf("计算总分计算平均成绩
");
    sum = Sum(head);//计算总分
    average = Average(sum, N);//计算平均成绩
    printf("sum=%d,average=%lf
", sum, average);

    printf("打印大于平均成绩的各个结点
");
    PrintUpAverage(head, average);//打印大于平均成绩的各个结点

    system("pause");
}

STU *init()//创建头指针，不存放数据
{
    STU *head = (STU*)malloc(sizeof(STU));//创建头结点
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(STU *head, int num, int score)//插入数据到尾部
{
    STU *new = (STU*)malloc(sizeof(STU));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//学号
    new->score = score;//成绩
    new->next = NULL;//最后指向NULL

    STU *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }
    
    p->next = new;//第3步，指针p指向指针new
}

void print(STU *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("num=%d,score=%d
", head->next->num, head->next->score);
        print(head->next);//递归
    }
}

int Sum(STU * head)//计算总分
{
    STU *p = head;//创建指针p指向头指针
    int sum = 0;
    while (p->next != NULL)
    {
        sum += p->next->score;
        p = p->next;
    }
    return sum;
}

double Average(int sum, int n)//计算平均成绩
{
    return 1.0*sum / n;
}

void PrintUpAverage(STU * head, double average)//打印大于平均成绩的各个结点
{
    STU *p = head;//创建指针p指向头指针
    while (p->next != NULL)
    {
        if (p->score > average)
        {
            printf("num=%d,score=%d
", p->next->num, p->next->score);
        }
        p = p->next;
    }
}

3 设链表中每个结点包括学号、成绩、和指针三个字段, 试编程序将成绩最高的结点作为链表的第一个结点,成绩最低的结点作为尾结点。

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

struct student
{
    int num;//学号
    int score;//成绩
    struct student *next;//下一个结点
};

typedef struct student STU;//简写

//涉及7个函数
STU *init();//创建头指针，不存放数据
void add(STU *head, int num, int score);//插入数据到尾部
void print(STU *head);//打印，递归
STU *FindMaxPre(STU *head);//查找最大值，返回最大值的前一个结点
STU *FindMinPre(STU *head);//查找最小值，返回最小值的前一个结点
void AdjustMax(STU *head);//调整最大值
void AdjustMin(STU *head);//调整最小值

void main()
{
    STU *head = init();//创建头指针，不存放数据

    add(head, 1, 10);//插入数据到尾部
    add(head, 2, 1);
    add(head, 3, 13);
    add(head, 4, 15);
    add(head, 5, 16);
    add(head, 6, 12);
    add(head, 7, 17);

    printf("打印，递归
");
    print(head);//打印，递归

    AdjustMax(head);//调整最大值
    AdjustMin(head);//调整最小值

    printf("调整以后
");
    print(head);//打印，递归

    system("pause");
}

STU *init()//创建头指针，不存放数据
{
    STU *head = (STU*)malloc(sizeof(STU));//创建头结点
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(STU *head, int num, int score)//插入数据到尾部
{
    STU *new = (STU*)malloc(sizeof(STU));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//学号
    new->score = score;//成绩
    new->next = NULL;//最后指向NULL

    STU *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }
    
    p->next = new;//第3步，指针p指向指针new
}

void print(STU *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("num=%d,score=%d
", head->next->num, head->next->score);
        print(head->next);//递归
    }
}

STU *FindMaxPre(STU *head)//查找最大值，返回最大值的前一个结点
{
    STU *p = head;//创建指针p，用于移动
    STU *MaxPre = head;//创建指针MaxPre，用于保存最大值的前一个结点
    if (p == NULL || MaxPre == NULL)
    {
        return NULL;
    }
    else
    {
        while (p->next != NULL)//遍历
        {
            if (MaxPre->next->score < p->next->score)//查找最大值
            {
                MaxPre = p;
            }
            p = p->next;//指针移动
        }

    }
    return MaxPre;//返回最大值的前一个结点
}

STU *FindMinPre(STU *head)//查找最小值，返回最小值的前一个结点
{

    STU *p = head;//创建指针p，用于移动
    STU *MinPre = head;//创建指针MinPre，用于保存最小值的前一个结点
    if (p == NULL || MinPre == NULL)
    {
        return NULL;
    }
    else
    {
        while (p->next != NULL)//遍历
        {
            if (MinPre->next->score > p->next->score)//查找最小值
            {
                MinPre = p;
            }
            p = p->next;//指针移动
        }
    }
    return MinPre;//返回最小值的前一个结点
}

void AdjustMax(STU *head)//调整最大值
{
    STU *p = FindMaxPre(head);//第1步，创建指针p，指向最大值的前一个结点
    STU *q = p->next;//第2步，创建指针q，指向最大值
    p->next = q->next;//第3步，跳过最大值
    q->next = head->next;//第4步，指针q的下一个结点指向原来的第一个
    head->next = q;//第5步，头指针指向最大值
}

void AdjustMin(STU *head)//调整最小值
{
    STU *p = FindMinPre(head);//第1步，创建指针p，指向最小值的前一个结点
    STU *q = p->next;//第2步，创建指针q，指向最小值
    p->next = q->next;//第3步，跳过最小值
    STU *r = head;//第4步，创建指针r，遍历
    while (r->next != NULL)
    {
        r = r->next;
    }
    r->next = q;//第5步，指针r指向最小值
    q->next = NULL;//第6步，最小值指向NULL
}

4 建立一个链表,每个结点包括:学号、姓名、性别、年龄。输入一个年龄,如果链表中的结点所包含的年龄等于此年龄,则将此结点删去。

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

struct student
{
    int num;//学号
    char name[10];//姓名
    int sex;//性别
    int age;//年龄
    struct student *next;//下一个结点
};

typedef struct student STU;//简写

//涉及4个函数
STU *init();//创建头指针，不存放数据
void add(STU *head, int num, const char *name, int sex, int age);//插入数据到尾部
void print(STU *head);//打印，递归
void delete(STU *head, int age);//根据年龄，删除结点

void main()
{
    int age = 0;//需要删除的年龄

    STU *head = init();//创建头指针，不存放数据

    add(head, 1, "abc", 1, 12);//插入数据到尾部
    add(head, 2, "def", 0, 13);
    add(head, 3, "ghi", 1, 14);
    add(head, 4, "jkl", 0, 14);
    add(head, 5, "mno", 1, 15);

    printf("打印，递归
");
    print(head);//打印，递归

    scanf("%d", &age);
    delete(head, age);//根据年龄，删除结点

    printf("删除以后
");
    print(head);//打印，递归

    system("pause");
}

STU *init()//创建头指针，不存放数据
{
    STU *head = (STU*)malloc(sizeof(STU));//创建头结点
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(STU *head, int num, const char *name, int sex, int age)//插入数据到尾部
{
    STU *new = (STU*)malloc(sizeof(STU));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//学号
    strcpy(new->name, name);//姓名
    new->sex = sex;//性别
    new->age = age;//年龄
    new->next = NULL;//最后指向NULL

    STU *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }

    p->next = new;//第3步，指针p指向指针new
}

void print(STU *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("num=%d,name=%s,sex=%d,age=%d
", head->next->num, head->next->name, head->next->sex, head->next->age);
        print(head->next);//递归
    }
}

void delete(STU * head, int age)//根据年龄，删除结点
{
    STU *p = head;//创建指针p
    STU *q = NULL;//创建指针q

    while (p->next != NULL)//遍历链表
    {
        if (age == p->next->age)//第1步，p指向需要删除的前面一个结点
        {
            q = p->next;//第2步，q指向需要删除的结点
            p->next = q->next;//第3步，跳过需要删除的
            free(q);//第4步，free
        }
        else
        {
            p = p->next;//继续遍历
        }
    }
}

5 逆序输出的数列

题目内容：

你的程序会读入一系列的正整数，预先不知道正整数的数量，一旦读到-1，就表示输入结束。然后，按照和输入相反的顺序输出所读到的数字，不包括最后标识结束的-1。

输入格式:

一系列正整数，输入-1表示结束，-1不是输入的数据的一部分。

输出格式：

按照与输入相反的顺序输出所有的整数，每个整数后面跟一个空格以与后面的整数区分，最后的整数后面也有空格。

输入样例：

1 2 3 4 -1

输出样例：

4 3 2 1

时间限制：2000ms内存限制：128000kb

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

struct num
{
    int num;//数字
    struct num *next;//下一个结点
};

typedef struct num NUM;//简写

//涉及4个函数
NUM *init();//创建头指针，不存放数据
void add(NUM *head, int num);//插入数据到尾部
void print(NUM *head);//打印，非递归
NUM *dao(NUM *head);//链表逆序，返回新的头指针

void main()
{
    int num = 0;

    NUM *head = init();//创建头指针，不存放数据

    scanf("%d", &num);

    while (num != -1)//输入 - 1表示结束
    {
        add(head, num);//插入数据到尾部
        scanf("%d", &num);
    }

    NUM *newhead = dao(head);//链表逆序，返回新的头指针

    print(newhead);//打印，非递归

    system("pause");
}

NUM *init()//创建头指针，不存放数据
{
    NUM *head = (NUM*)malloc(sizeof(NUM));//创建头结点
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(NUM *head, int num)//插入数据到尾部
{
    NUM *new = (NUM*)malloc(sizeof(NUM));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//学号
    new->next = NULL;//指针new指向NULL

    NUM *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }

    p->next = new;//第3步，指针p指向指针new
}

NUM *dao(NUM *head)//链表逆序，返回新的头指针
{
    NUM * p = NULL;//创建指针p
    NUM * q = head->next;//创建指针q
    NUM * r = NULL;//创建指针r

    while (q)
    {
        r = q->next;//指针r指向q的下一个结点
        q->next = p;//指针q指向前面结点
        p = q;//移动指针p
        q = r;//移动指针q
    }

    NUM *newhead = (NUM *)malloc(sizeof(NUM));//创建指针newhead，作为新头指针
    newhead->next = p;//新头指针指向指针p
    return newhead;//返回新头指针
}

void print(NUM *head)//打印，非递归
{
    NUM *p = head;//创建指针，用于移动
    int count = 0;//计数器

    while (p->next != NULL)
    {
        if (count)
        {
            printf(" ");
        }
        printf("%d", p->next->num);
        p = p->next;
        count++;
    }
}

6 插入排序。许多玩牌的人是以这样的方式来对他们手中的牌进行排序的：设手中原有3张牌已排好序，抓1张新牌，若这张新牌的次序在原来的第2张牌之后，第3张牌之前，那么就把这张新牌放在第3张牌的位置上，原来的第3张改为第4张， 然后再抓新牌。按着这个算法，编写一个排序程序。

注：开始一张牌也没有，从第一张牌开始抓起。

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

struct card
{
    int num;//牌号
    struct card *next;//下一个结点
};
typedef struct card CARD;//简写

CARD *init();//创建头结点，不存放数据
void insert(CARD *head, int num);//插入结点，升幂排序
void print(CARD *head);//打印链表，递归

void main()
{
    CARD *head = init();//创建头结点，不存放数据

    insert(head, 5);//插入结点，升幂排序
    insert(head, 4);
    insert(head, 7);
    insert(head, 6);

    print(head);//打印链表，递归
}

CARD *init()//创建头结点，不存放数据
{
    CARD *head = (CARD *)malloc(sizeof(CARD));//创建头指针
    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void insert(CARD *head, int num)//插入结点，升幂排序
{
    if (head == NULL)//如果传入空指针，返回
    {
        return;
    }

    CARD *new = (CARD *)malloc(sizeof(CARD));//创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->num = num;//指针new存储新数据
    new->next = NULL;//指向new指向NULL

    if (head->next == NULL)//插入结点第1种可能，原来链表为空，即是第一张牌
    {
        printf("插入结点第1种可能，原来链表为空，即是第一张牌
");
        head->next = new;//头指针指向指针new
    }
    else if (head->next->num > num)//插入结点第2种可能，比原来的第一张牌更小，即是插入在原来的第一张牌的前面
    {
        printf("插入结点第2种可能，比原来的第一张牌更小，即是插入在原来的第一张牌的前面
");
        new->next = head->next;//指针new指向原来的第一个结点
        head->next = new;//头指针指向指针new
    }
    else
    {
        CARD *p = head;//创建指针p，用于移动
/*需要注意的是：while中两个条件的顺序不能对调！当p->next == NULL时，C编译程序将短路掉第二个条件，不做判断，
否则如果先判断p->next->num < num的条件，由于p->next中的值已为NULL，这是再要访问p->next->num，将会发生访问虚地址的错误操作*/
        while ((p->next != NULL) && (p->next->num < num))//当p指向的不是NULL，且p指向的下一个牌号比新牌小，继续移动指针p
        {
            p = p->next;//指针p移动
        }
        if (p->next == NULL)//插入结点第3种可能，新牌最大，即是插入到最后
        {
            printf("插入结点第3种可能，新牌最大，即是插入到最后
");
            p->next = new;//原来的最后一张牌指向指针new
        }
        else//插入结点第4种可能，插入到中间
        {
            printf("插入结点第4种可能，插入到中间
");
            new->next = p->next;//指针new指向指针p下一个结点
            p->next = new;//指针p指向指针new
        }
    }
}

void print(CARD *head)//打印链表，递归
{
    if (head->next == NULL)//结束递归
    {
        return;
    }
    else
    {
        printf("num=%d
", head->next->num);
        print(head->next);//继续递归
    }
}

7 有两个链表ａ和ｂ。设结点中包含学号、姓名。从ａ链表中删除与ｂ链表中有相同学号的那些结点。

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

struct student
{
    int ID;//学号
    char name[100];//姓名
    struct student *next;//下一个结点
};

typedef struct student STUDENT;

STUDENT *init();//创建头指针，不存放数据
void add(STUDENT *head, int ID, const char *name);//插入数据到尾部
void print(STUDENT *head);//打印，递归
void delete(STUDENT * headA, STUDENT * headB);//从ａ链表中删除与ｂ链表中有相同学号的那些结点

void main()
{
    STUDENT *headA = init();//创建头指针，不存放数据
    STUDENT *headB = init();//创建头指针，不存放数据

    add(headA, 1, "abc");//插入数据到尾部
    add(headA, 2, "def");
    add(headA, 3, "ghi");
    add(headA, 3, "jkl");

    add(headB, 5, "mno");//插入数据到尾部
    add(headB, 3, "pqr");
    add(headB, 2, "stu");
    add(headB, 7, "vwx");

    printf("打印链表ａ，递归
");
    print(headA);
    printf("打印链表b，递归
");
    print(headB);

    printf("从ａ链表中删除与ｂ链表中有相同学号的那些结点
");
    delete(headA, headB);//从ａ链表中删除与ｂ链表中有相同学号的那些结点
    printf("打印链表ａ，递归
");
    print(headA);
    printf("打印链表b，递归
");
    print(headB);
}

STUDENT *init()//创建头指针，不存放数据
{
    STUDENT *head = (STUDENT *)malloc(sizeof(STUDENT));//创建头指针

    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void add(STUDENT *head, int ID, const char *name)//插入数据到尾部
{
    STUDENT *new = (STUDENT *)malloc(sizeof(STUDENT));//第1步，创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->ID = ID;//学号
    strcpy(new->name, name);//姓名
    new->next = NULL;//最后指向NULL

    STUDENT *p = head;//第2步，创建指针p，用于移动
    if (p == NULL)
    {
        return;
    }
    while (p->next != NULL)//遍历
    {
        p = p->next;
    }

    p->next = new;//第3步，指针p指向指针new
}

void print(STUDENT *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("ID=%d,name=%s
", head->next->ID, head->next->name);
        print(head->next);
    }
}

void delete(STUDENT * headA, STUDENT * headB)//从ａ链表中删除与ｂ链表中有相同学号的那些结点，升级版delete
{
    STUDENT *pa = headA;//创建指针pa指向链表a
    STUDENT *pb = headB;//创建指针pb指向链表b
    STUDENT *q = NULL;//创建指针q
    int flag = 0;//1代表找到有相同的，0代表没有找到

    while (pa->next != NULL)//外循环，a链表，需要删除结点的链表
    {
        pb = headB;//恢复到链表b开始，重新遍历
        flag = 0;//0代表没有找到

        while (pb->next != NULL)//内循环，b链表，查找相同结点的链表
        {
            if (pa->next->ID == pb->next->ID)//第1步，pa指向需要删除的前面一个结点
            {
                flag = 1;//1代表找到有相同的
                q = pa->next;//第2步，q指向需要删除的结点
                pa->next = q->next;//第3步，跳过需要删除的
                free(q);//第4步，free
                break;//结束链表b的遍历
            }
            else
            {
                pb = pb->next;//继续遍历
            }
        }

        if (!flag)//如果没有找到，则链表a继续向前。如果找到了，之前在if语句中已经跳过需要删除的，链表a已经向前了，不能重复
        {
            pa = pa->next;//继续遍历
        }
    }
}

8 建立一个链表，每个结点包括的成员为：职工号、工资。用new函数开辟新结点。要求链表包括５个结点，从键盘输入结点中的有效数据。然后把这些结点的数据打印出来。要求用函数creat来建立链表,用list函数来输出数据。这５个职工的职工号是101,103,105,107,109。

在上题的基础上，新增加一个职工数据。这个新结点不放在最后，而是按职工号顺序插入，新职工号为106。写一函数insert来插入结点。

在上两题的基础上，写一函数，用来删除一个结点（按指定职工号删除）。

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

struct staff
{
    int ID;//职工号
    int salary;//工资
    struct staff *next;//下一个结点
};
typedef struct staff STAFF;//简写

STAFF *create();//创建头结点，不存放数据
void insert(STAFF *head, int ID, int salary);//插入结点，升幂排序
void list(STAFF *head);//打印，递归
void delete(STAFF * head, int ID);//根据指定职工号删除结点

void main()
{
    STAFF *head = create();//创建头结点，不存放数据

    insert(head, 101, 1000);//插入结点，升幂排序
    insert(head, 103, 2000);
    insert(head, 105, 3000);
    insert(head, 107, 4000);
    insert(head, 109, 5000);

    insert(head, 106, 6000);

    list(head);//打印，递归

    printf("根据指定职工号删除结点
");

    delete(head, 105);//根据指定职工号删除结点
    delete(head, 103);

    list(head);//打印，递归
}

STAFF *create()//创建头结点，不存放数据
{
    STAFF *head = (STAFF *)malloc(sizeof(STAFF));//创建头指针

    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void insert(STAFF *head, int ID, int salary)//插入结点，升幂排序
{
    if (head == NULL)//如果传入空指针，返回NULL
    {
        return;
    }

    STAFF *new = (STAFF *)malloc(sizeof(STAFF));//创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->ID = ID;//职工号
    new->salary = salary;//工资
    new->next = NULL;//最后指向NULL

    if (head->next == NULL)//第1种可能，原来链表为空，即是第一个职工号
    {
        printf("第1种可能，原来链表为空，即是第一个职工号
");
        head->next = new;//头指针指向指针new
    }
    else if (head->next->ID > ID)//第2种可能，原来的第一个职工号大于新插入的，即是插入在原来的第一个职工号的前面
    {
        printf("第2种可能，原来的第一个职工号大于新插入的，即是插入在原来的第一个职工号的前面
");
        new->next = head->next;//指针new指向原来的第一个结点
        head->next = new;//头指针指向指针new
    }
    else
    {
        STAFF *p = head;//创建指针p，用于移动
/*需要注意的是：while中两个条件的顺序不能对调！当p->next == NULL时，C编译程序将短路掉第二个条件，不做判断，
否则如果先判断p->next->ID < ID的条件，由于p->next中的值已为NULL，这是再要访问p->next->ID，将会发生访问虚地址的错误操作*/
        while ((p->next != NULL) && (p->next->ID < ID))//当p指向的不是NULL，且p指向的下一个职工号比新插入小，继续移动指针p
        {
            p = p->next;
        }
        if (p->next == NULL)//第3种可能，新插入的职工号最大，即是插入到最后
        {
            printf("第3种可能，新插入的职工号最大，即是插入到最后
");
            p->next = new;//原来的最后结点指向指针new
        }
        else//第4种可能，插入到中间
        {
            printf("第4种可能，插入到中间
");
            new->next = p->next;//指针new指向指针p下一个结点
            p->next = new;//指针p指向指针new
        }
    }
}

void list(STAFF *head)//打印，递归
{
    if (head->next == NULL)
    {
        return;
    }
    else
    {
        printf("ID=%d,salary=%d
", head->next->ID, head->next->salary);
        list(head->next);
    }
}

void delete(STAFF *head, int ID)//根据指定职工号删除结点
{
    STAFF *p = head;//创建指针p
    STAFF *q = NULL;//创建指针q

    while (p->next != NULL)//遍历链表
    {
        if (p->next->ID == ID)//第1步，p指向需要删除的前面一个结点
        {
            q = p->next;//第2步，q指向需要删除的结点
            p->next = q->next;//第3步，跳过需要删除的
            free(q);//第4步，free
        }
        else
        {
            p = p->next;//继续遍历
        }
    }
}

9 建立两个链表，来表示x幂的两个多项式，链表中的结点有三个字段coef、exp和next，分别表示多项式每项的系数、x的指数及指向下一项的指针。编一程序，按ｘ的降幂输入多项式的系数和指数，建立两个链表，然后编一函数来完成把两个多项式的链表叠加到第三个链表中。例如:

第一个多项式为: -4x8 +5x6 +3x4 -4x的链表为:

-4 8 5 6 3 4 -4 1

第二个多项式为: 5x9 -5x8 -3x4 +7x的链表为:

5 9 -5 8 -3 4 7 1

结果的多项式为: 5x9 -9x8 +5x6 +3x

5 9 -9 8 5 6 3 1

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

struct mi
{
    int coef;//系数
    int exp;//指数
    struct mi *next;//下一个结点
};
typedef struct mi MI;//简写

MI *create();//创建头结点，不存放数据
void insert(MI *head, int coef, int exp);//插入结点，降幂排序
void list(MI *head);//打印，非递归
void MiAdd(MI *head3, MI *head1, MI *head2);//把两个多项式的链表叠加到第三个链表中

void main()
{
    MI *head1 = create();//创建头结点，不存放数据
    MI *head2 = create();
    MI *head3 = create();

    insert(head1, -4, 8);//插入结点，降幂排序
    insert(head1, 5, 6);
    insert(head1, 3, 4);
    insert(head1, -4, 1);

    insert(head2, 5, 9);//插入结点，降幂排序
    insert(head2, -5, 8);
    insert(head2, -3, 4);
    insert(head2, 7, 1);

    list(head1);//打印，非递归
    list(head2);

    MiAdd(head3, head1, head2);//把两个多项式的链表叠加到第三个链表中

    list(head3);//打印，非递归
}

MI *create()//创建头结点，不存放数据
{
    MI *head = (MI *)malloc(sizeof(MI));//创建头指针

    if (head == NULL)
    {
        printf("分配内存失败
");
        return NULL;
    }
    else
    {
        head->next = NULL;//最后指向NULL
        return head;//返回头指针
    }
}

void insert(MI *head, int coef, int exp)//插入结点，降幂排序
{
    if (head == NULL)//如果传入空指针，返回NULL
    {
        return;
    }

    MI *new = (MI *)malloc(sizeof(MI));//创建指针new，用于存储新数据
    if (new == NULL)
    {
        printf("分配内存失败
");
        return;
    }
    new->coef = coef;//系数
    new->exp = exp;//指数
    new->next = NULL;//最后指向NULL

    if (head->next == NULL)//插入结点第1种可能，原来链表为空，即是第一个指数
    {
        printf("插入结点第1种可能，原来链表为空，即是第一个指数
");
        head->next = new;//头指针指向指针new
    }
    else if (exp > head->next->exp)//插入结点第2种可能，新插入的指数大于原来的第一个指数，即是插入在原来的第一个指数的前面
    {
        printf("插入结点第2种可能，新插入的指数大于原来的第一个指数，即是插入在原来的第一个指数的前面
");
        new->next = head->next;//指针new指向原来的第一个结点
        head->next = new;//头指针指向指针new
    }
    else
    {
        MI *p = head;//创建指针p，用于移动
/*需要注意的是：while中两个条件的顺序不能对调！当p->next == NULL时，C编译程序将短路掉第二个条件，不做判断，
否则如果先判断(p->next->exp > exp)的条件，由于p->next中的值已为NULL，这是再要访问(p->next->exp)，将会发生访问虚地址的错误操作*/
        while ((p->next != NULL) && (p->next->exp > exp))//当p指向的不是NULL，且p指向的下一个指数比新插入的指数大，继续移动指针p
        {
            p = p->next;
        }
        if (p->next == NULL)//插入结点第3种可能，新插入的指数最小，即是插入到最后
        {
            printf("插入结点第3种可能，新插入的指数最小，即是插入到最后
");
            p->next = new;//原来的最后结点指向指针new
        }
        else//插入结点第4种可能，插入到中间
        {
            printf("插入结点第4种可能，插入到中间
");
            new->next = p->next;//指针new指向指针p下一个结点
            p->next = new;//指针p指向指针new
        }
    }
}

void list(MI *head)//打印，非递归
{
    MI *p = head;

    while (p->next)
    {
        if (p->next->coef >= 0)//如果系数是正数或者0，前面加上+
        {
            printf("+");
        }
        printf("%dx(%d)", p->next->coef, p->next->exp);
        p = p->next;
    }

    printf("
");
}

void MiAdd(MI *head3, MI *head1, MI *head2)//把两个多项式的链表叠加到第三个链表中
{
    MI *p = head1;//p指向head1
    MI *q = head2;//q指向head2

    while (p->next || q->next)
    {
        if (p->next && q->next)//链表相加第1种可能，如果p的下一个结点和q的下一个结点都不为空
        {
            printf("链表相加第1种可能，如果p的下一个结点和q的下一个结点都不为空
");
            if (p->next->exp > q->next->exp)//链表相加第1.1种可能，如果p的下一个结点的指数大于q的下一个结点的指数
            {
                printf("链表相加第1.1种可能，如果p的下一个结点的指数大于q的下一个结点的指数
");
                insert(head3, p->next->coef, p->next->exp);//把p的结点插入到head3
                p = p->next;//p继续移动
            }
            else if (p->next->exp < q->next->exp)//链表相加第1.2种可能，如果p的下一个结点的指数小于q的下一个结点的指数
            {
                printf("链表相加第1.2种可能，如果p的下一个结点的指数小于q的下一个结点的指数
");
                insert(head3, q->next->coef, q->next->exp);//把q的结点插入到head3
                q = q->next;//q继续移动
            }
            else//链表相加第1.3种可能，如果p的下一个结点的指数等于q的下一个结点的指数
            {
                printf("链表相加第1.3种可能，如果p的下一个结点的指数等于q的下一个结点的指数
");
                if ((p->next->coef) + (q->next->coef))//链表相加第1.3.1种可能，如果p的下一个结点的系数和q的下一个结点的系数相加不等于0
                {
                    printf("链表相加第1.3.1种可能，如果p的下一个结点的系数和q的下一个结点的系数相加之和不等于0
");
                    insert(head3, (p->next->coef) + (q->next->coef), p->next->exp);//把系数相加后的结点插入到head3
                }
                else//链表相加第1.3.2种可能，如果p的下一个结点的系数和q的下一个结点的系数相加之和等于0，不需要插入
                {
                    printf("链表相加第1.3.2种可能，如果p的下一个结点的系数和q的下一个结点的系数相加之和等于0，不需要插入
");
                }

                p = p->next;//p继续移动
                q = q->next;//q继续移动
            }
        }
        else if (p->next && q->next == NULL)//链表相加第2种可能，如果p下一个结点不为空，q下一个结点为空
        {
            printf("链表相加第2种可能，如果p下一个结点不为空，q下一个结点为空
");
            insert(head3, p->next->coef, p->next->exp);//把p的结点插入到head3
            p = p->next;//p继续移动
        }
        else//链表相加第3种可能，如果p下一个结点为空，q下一个结点不为空
        {
            printf("链表相加第3种可能，如果p下一个结点为空，q下一个结点不为空
");
            insert(head3, q->next->coef, q->next->exp);//把q的结点插入到head3
            q = q->next;//q继续移动
        }
    }
}