单向链表操作：新建，输出，删除，插入

1.新建

算法：使p1指向新开辟的结点，p2指向链表中最后一个结点，把p1所指的结点连接在p2所指结点的后面，用“p2->next=p1”来实现。

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

#define LEN sizeof(struct student)

struct student{
    long num;
    float score;
    struct student *next;
};

struct student *creat(void){
    struct student *head=NULL,*p1,*p2;
    int n=0;

    p1=(struct student *)malloc(LEN);
    p2=p1;

    printf("Input one student's data:
");
    scanf("%ld,%f",&p1->num,&p1->score);
    while(p1->num!=0)
    {
        n++;
        if(n==1)
            head=p1;
        else
            p2->next=p1;
        p2=p1;
        p1=(struct student *)malloc(LEN);
        printf("Input one student's data:
");
        scanf("%ld,%f",&p1->num,&p1->score);
    }
    p2->next=NULL;
    return head;
}

2.输出

void print(struct student *head)
{
    struct student *p;
    for(p=head;p!=NULL;p=p->next)
    {
        printf("%ld,%f
",p->num,p->score);
    }
}

3.删除

 这是我用for循环编写的：

struct student *del(struct student *head,long num){
    struct student *p1,*p2;
    if(head==NULL)
        printf("The list is NULL.
");
    else
        for(p1=head;p1!=NULL;p1=p1->next)
        {
            if(p1->num==num)
            {
                if(p1==head)
                    head=p1->next;
                else
                    p2->next=p1->next;
                break;
            }
            else
            {
                p2=p1;
            }
        }

    if(p1==NULL)
        printf("cannot find the %ld.
",num);
    return head;
}

书上用while循环编写的：

struct student *del(struct student *head,long num){
    struct student *p1,*p2;
    if(head==NULL)
    {
        printf("The list is NULL.
");
        return head;
    }
    p1=head;
    while(p1->num!=num&&p1->next!=NULL)//当前结点不是要删除的结点而且后面还有结点。
    {
        p2=p1;
        p1=p1->next;
    }
    if(p1->num==num)
    {
        if(p1==head)
            head=p1->next;
        else
            p2->next=p1->next;
    }
    else
        printf("%ld cannot be found.
",num);
    return head;
}

 4.插入

使用for循环编写：

struct student *insert(struct student *head,struct student *stu){
    struct student *p0,*p1,*p2;
    p0=stu;
    for(p1=head;p1!=NULL;p1=p1->next)
    {
        if(p1->num < p0->num)
            p2=p1;
        else
        {
            if(p1==head)
                head=p0;
            else
                p2->next=p0;
            p0->next=p1;
            break;
        }
    }
    if(p1==NULL)
    {
        if(p1==head)
            head=p0;
        else
            p2->next=p0;
        p0->next=NULL;
    }
    return head;
}

使用while循环编写：

struct student *insert(struct student *head,struct student *stu){
    struct student *p0,*p1,*p2;
    p0=stu;
    if(head==NULL)
    {
        head=p0;
        p0->next=NULL;
    }
    else
    {
        p1=head;
        while(p1->num<p0->num&&p1->next!=NULL)
        {
            p2=p1;
            p1=p1->next;
        }
        if(p1->num>p0->num)
        {
            if(p1==head)
                head=p0;
            else
                p2->next=p0;
            p0->next=p1;
        }
        else
        {
            p1->next=p0;
            p0->next=NULL;
        }
    }
    return head;
}

我刚开始用的函数原型是：

struct student *insert(struct student *head)

插入的结点在函数内部产生，事实证明这样做是不行的。因为插入的结点数据在函数调用完之后就释放了，没有保存。

后来函数原型改为：

struct student *insert(struct student *head,struct student stu)

插入的结点在主函数内产生，经过一番试验后，发现也不对。新结点的数据传递给形参stu，形参stu有自己的地址，insert函数把形参stu连接在了链表中，函数调用完之后，形参stu的值就释放了，链表中新结点处的值为不确定的值。

链表学习心得：在对链表进行操作的过程中，要设两个循环变量指针：p1和p2。其中p1指向当前要进行操作或处理的结点，p2指向当前结点的前一个结点，当前结点的后一个结点可以直接用p1->next表示。循环遍历数组的话，可以用p++和p--指向后一个元素和前一个元素，但是因为链表中的结点不是连续存放的，所以只能用设两个循环变量的方法遍历数组。