今天刚讲完C语言的结构体，过几天就要考试了，要复习一下，Java的学习应该要推迟几天，老师布置了几道关于链表的练习，自己亲手码的一百多行代码，发上来记录一下，其中的算法应该还可以进行优化，但由对于算法优化和深入学习，想等到下学期学数据结构时在进行，现在只求实现出来吧 (:з」∠)
题目：1.有链表a和b，他们中每个节点都包括学号，姓名，成绩，编程从a表中删去b表中有相同学号的结点。
用函数del_list(struct stsource,struct sttarget)实现。
struct st{long num;char name[12];float socre;struct st* next};
要求同时给出主调函数(main函数的实现)
2.把一个链表按反序排序，即将原链头当做链尾，原链尾当做链头。
用函数inverted_list(struct st* head)实现；

注：其实del_list函数因为可能要对头指针进行操作，所以应该传入头指针的地址才行，故形参应该为struct st ** source，是双重指针，不知这里是不是老师题目给错了

#include <stdio.h>
#include <stdlib.h>                     //用到malloc函数要引入该头文件
struct st                               //用typedef可以省不少代码,老师不让用_(:з」∠)_ 
{
    long num;
    char name[12];
    float score;
    struct st * next;
};
void main()
{
    void creat_LinkList(struct st** Head,int n );
    void print_LinkList(struct st* Head );
    struct st * del_list (struct st **source,struct st* target);
    struct st* inverted_list(struct st*head);
    struct st* firstList = NULL,*secondList =NULL;      //创建两个链表指针,即头指针
    creat_LinkList(&firstList,3);
    creat_LinkList(&secondList,2);
    //print_LinkList(firstList);
    //print_LinkList(secondList);
    del_list(&firstList,secondList);
    print_LinkList(firstList);
    printf("--------------------------");
    firstList = inverted_list(firstList);
    print_LinkList(firstList);
    
}

void creat_LinkList(struct st** Head,int n )    //定义创造n个结点的链表的函数，形参head是双重指针,因为要对头指针操作
{
    struct st *p ;
    p = (struct st*)malloc(sizeof(struct st));
    void print_LinkList(struct st* Head );
    *Head = p;
    printf("输入第1个结点的号码,姓名,分数\n");
    scanf("%d%s%f",&(p->num),&(p->name),&(p->score));
    for (int i = 2;i <= n;i++)
    {
        p->next = (struct st*)malloc(sizeof(struct st));
        p = p->next;
        printf("输入第%d个结点的号码,姓名,分数\n",i);
        scanf("%d%s%f",&(p->num),&(p->name),&(p->score));
    }
    p->next =NULL;
}

void print_LinkList(struct st* Head )                       //定义打印链表的函数,方便调试
{
    struct st* p;
    p=Head;
    while (p)
    {
        printf("号码:%d,姓名:%s,分数:%f\n",p->num,p->name,p->score);
        p = p->next;
    }
}
//利用两个指针删除,p指向前驱,p1指向与链表2比较的结点,法2:利用单个指针p->next->next来判断,只要对头结点做特殊处理即可
//法2有空再写
struct st * del_list (struct st **source,struct st* target)
{
    struct st *p1,*p2,*p,*temp;         //p1定位第一个链表中将要与第二个链表比较的结点,p定位p1的前驱结点，方便删除操作
    int tag;
    p1 = *source;
    p = p1;             
    while (p1)
    {
        p2 = target;
        tag = 0;                        //标记在遍历第二个链表过程中是否进行了删除操作
        while (p2)
        {
            if (p1->num == p2->num)     //删除操作时对头指针的特殊处理
            {
                if (p1 == *source)
                {
                    *source = p1->next;
                    free(p1);
                    p1 = *source;
                    p = p1;
                    tag = 1;
                }
                else
                {
                    p->next = p1->next;
                    temp = p1;
                    p1 = temp->next;
                    free(temp);
                    tag = 1;            //进行了删除操作,指针p不动,指针p1指向下一结点
                    break;
                }
            }
            p2 = p2->next;
        }
        if (tag == 0)                   //没有进行删除操作,指针p和p1都指向下一个结点
        {   p = p1;                     //p作为p1的前驱结点
            p1 = p1->next;
        }       
    }
}

struct st* inverted_list(struct st*head)        //链表反转的函数
{
    struct st *first,*p1,*p2,*p3;
    if (head==NULL) 
        return head;
    else 
    {
        first=head;                             //链表不为空时
        p1=head;
        p2=p1->next;
        while (p2)
        {
            p3=p2->next;                        //p3记录p2的下一个结点,在改变p2指向后仍能找到其后一个结点
            p2->next=p1;                        //反转p1和p2结点
            p1=p2;                              //将p1,p2,p3调整,指向下一次调成的两个结点
            p2=p3;            
        }
        head=p1;
        first->next=NULL;
        return head;
    }    
}