C语言链表

单向链表

与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。
缺点：
1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成)。
2、查找结点时链式存储要比顺序存储慢（每个节点地址不连续、无规律）。
优点：
1、插入、删除灵活 (不必移动节点，只要改变节点中的指针，但是需要先定位到元素上)。
2、有元素才会分配结点空间，不会有闲置的结点。

定义

struct node
{
    int y;
    NODE * next;//指针
}data;
H=(NODE*)malloc(n*sizeof(NODE));
        H->next=NULL;

尾插法建立链表

void creat(NODE * H,int n)
{
    int x,i;
    NODE *p,*r;
    r=H;
    for(i=0;i<n;i++)
    {
        scanf("%d",&x);
        p=(NODE *)malloc(sizeof(NODE));
        p->y=x;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

头插法建立链表

void creat(NODE * H,int n)
{
    int x,i;
    NODE *p,*r;
    r=H;
    for(i=0;i<n;i++)
    {
        scanf("%d",&x);
        p=(NODE *)malloc(sizeof(NODE));
        p->y=x;
        p->next=H->next;
        H->next=p;
    }

}

查找

STU * search(STU *head,int x,int *w)
{
    STU *p;
    int n=0;
    p=head->next;
    while(p!=NULL&&p->no!=x)
    {
        n++;
        p=p->next;
    }
    if(p!=NULL)
    {
        *w=n+1;
        return p;
    }
    else
    {
        *w=0;
        return NULL;
    }
}

找到所要查找的节点的前驱

N* search(N *H,int y)
{
    N *p;
    p=H;
    if(p->next->x==y)
    {
        printf("没有前驱\n");
        return NULL;
    }
    while(p->next!=NULL&&p->next->x!=y)//谨记p->next!=NULL
    {
        p=p->next;
    }
    if(p->next==NULL)
    {
        printf("x不存在\n");
        return NULL;
    }
    else return p;
}

删除

void delete(N *H,int y)
{
    N *p,*r,*q;
    p=H;
    r=p->next;
    while(r!=NULL)
    {
        if(r->x==y)
        {
            q=r;
            p->next=r->next;
            free(q);
            r=p->next;
        }
        else
        {
            p=r;
            r=r->next;
        }
    }
}

有序插入一个有序链表

void search(N *H,int y)
{
    N *pre,*p,*q;
    pre=H;
    p=pre->next;
    while(p!=NULL&&p->x<=y)
    {
       pre=p;
        p=p->next;
    }
    q=(N*)malloc(sizeof(N));
    q->x=y;
    pre->next=q;
    q->next=p;
}

建立一个有序链表

void insert(N *H,int y)
{
    N *pre,*p,*q;
    pre=H;
    p=H->next;
    while(p!=NULL&&p->x<y)
    {
        pre=p;
        p=p->next;
    }
    q=(N*)malloc(sizeof(N));
    q->x=y;
    q->next=p;
    pre->next=q;

}
void creat(N *H,int n)
{
    int i,y;
    for(i=0;i<n;i++)
    {
        scanf("%d",&y);
        insert(H,y);
    }
}

复杂的链表内容

typedef struct node N;
typedef struct mode M;
struct mode
{
    int num;
    char name[10];
    double cj[3],ave,sum;

};
struct node
{
    M data;
    struct node *next;
};
void input(N *p)
{
    char xm[20];
    int xh,i;
    double fs[4];
    scanf("%d %s",&xh,xm);
    p->data.num=xh;
    strcpy(p->data.name,xm);
    p->data.sum=0.0;
    for(i=0;i<3;i++)
    {
        scanf("%lf",&fs[i]);
        p->data.cj[i]=fs[i];
        p->data.sum=p->data.sum+fs[i];
    }
    p->data.ave=p->data.sum/3;
}

void creat(N *H,int n)
{
    int i;
    N *p,*r=H;
    for(i=0;i<n;i++)
    {
        p=(N*)malloc(sizeof(N));
        input(p);
        r->next=p;
        r=p;
    }
    r->next=NULL;

}

输出

void output(N *H)
{
    N *p;
    p=H->next;
    while(p!=NULL)
    {
        printf("%d",p->x);
        p=p->next;
    }
}