基本算法——链表的一些基本操作

在简单的算法中，链表是我们经常用到的，同时，链表有时候也是让我们很头痛的一种基本操作。

下面代码中，包含了链表的一些基本操作:

　　1.链表的建立:(1)头插法　　(2)尾插法　　(3)有序建立

　　2.链表的插入

　　3.链表的删除

　　4.链表逆置

　　5.在链表中查找倒数元素

　　6.在链表中查找中间元素

　　7.判断链表是否有环

　　8.有序合并两个链表

声明如下:

#ifndef _HEAD_H
#define _HEAD_H
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
typedef struct LINK
{
    int num;
    struct LINK *next;
}NODE,*pNODE;
void link_travers(pNODE head,void (*pFUN)(pNODE p));//用函数（*pFUN）遍历链表
void link_head(pNODE *head,int size);    //头插法建立链表
void link_last(pNODE *head,int size);    //尾插法建立链表
void link_sortCreat(pNODE *head,int size);//有序建立链表
void link_expand(pNODE *head,int num);        //在链表中插入一个值
void link_del(pNODE *head,int num);            //删除链表中值为num的节点
void link_reverse(pNODE *head);            //链表逆置
void link_search(pNODE head,int num);    //找到链表中倒数元素
void link_searchMID(pNODE head);        //查找中间节点的值
void link_circle(pNODE head);            //判断一个链表是否有环
void link_greme(pNODE *head1,pNODE *head2);    //有序合并两个链表

#endif

实现代码如下:

#include "head.h"
void link_travers(pNODE head,void (*pFUN)(pNODE p))//遍历链表
{
    while(head)
    {
        pFUN(head);
        head=head->next;
    }
}
void link_head(pNODE *head,int size)        //头插法
{
    pNODE p;
    *head=NULL;
    while(size>0)
    {
        size--;
        p=(pNODE)calloc(1,sizeof(NODE));
        p->num=rand()%1000;
        p->next=*head;
        *head=p;
    }
}

void link_last(pNODE *head,int size)        //尾插法
{
    pNODE tail,p;
    *head=tail=NULL;
    while(size>0)
    {
        size--;
        p=(pNODE)calloc(1,sizeof(NODE));
        p->num=rand()%1000;
        if(*head==NULL)
            *head=tail=p;
        else
            tail=tail->next=p;
    }
}

void link_sortCreat(pNODE *head,int size)        //有序建立
{
    pNODE pC,pP,pnew;
    while(size>0)
    {
        pnew=(pNODE)calloc(1,sizeof(NODE));
        pnew->num=rand()%1000;
        if(*head==NULL)
            *head=pnew;
        else
        {
            pC=*head;
            pP=NULL;
            while(pC!=NULL)
            {
                if(pC ->num < pnew ->num)
                {
                    pP=pC;
                    pC=pC->next;
                }
                else
                    break;
            }
            if(pP==NULL)
            {
                pnew->next=*head;
                *head=pnew;
            }
            else
            {
                pnew->next=pC;
                pP->next=pnew;
            }
        }
        size--;
    }
}


void link_expand(pNODE *head,int num)        //增加新值
{
    pNODE pnew;
    pNODE pP,pC;
    pnew=(pNODE)calloc(1,sizeof(NODE));
    pnew->num=num;
    if(*head==NULL)
        *head=pnew;
    else{
        pC=*head;
        pP=NULL;
        while(pC)
        {
            if(pC->num < pnew->num)
            {
                pP=pC;
                pC=pC->next;
            }
            else
                break;
        }
        if(pP==NULL)
        {
            pnew->next=*head;
            *head=pnew;
        }
        else
        {
            pnew->next=pC;
            pP->next=pnew;
        }
    }
    printf("插入成功!!
");
}


void link_del(pNODE *head,int num)            //删除值为num的节点
{
    pNODE pC,pP,ptmp;
    if(*head==NULL)
        printf("链表为空!!删除失败!!
");
    else
    {
        pC=*head;
        pP=NULL;
        while(pC)
        {
            if(pC->num == num)
            {
                if(pP==NULL)
                {
                    ptmp=*head;
                    *head=(*head)->next;
                    free(ptmp);
                    pC=*head;
                }
                else
                {
                    ptmp=pC;
                    pP->next=pC->next;
                    free(ptmp);
                    pC=pP->next;
                }
                printf("删除成功!!
");
            }
            else
            {
                pP=pC;
                pC=pC->next;
            }
        }
    }
}


void link_reverse(pNODE *head)                //链表逆置
{
    pNODE p,pnext;
    if(*head==NULL)
        printf("链表为空!!无法逆置!!
");
    else
    {
        p=*head;
        *head=NULL;
        while(p)
        {
            pnext=p->next;
            p->next=*head;
            *head=p;
            p=pnext;
        }
    }
}

void link_search(pNODE head,int num)        //查找倒数节点的值
{
    int i=1;
    pNODE pf,pl;
    if(head==NULL)
        printf("链表为空!!查找失败!!
");
    else
    {
        pf=pl=head;
        while(pf)
        {
            pf=pf->next;
            if(i>num)
                pl=pl->next;
            i++;
        }
        if(i<=num)
            printf("该链表中没有这么多数据!!查找失败!!
");
        else
            printf("倒数第%d个元素为%d
",num,pl->num);
    }
}

void link_searchMID(pNODE head)
{
    pNODE pf,pl;
    if(head==NULL)
        printf("该链表为空!!查找失败!!
");
    else
    {
        pf=pl=head;
        while(pf)
        {
            pf=pf->next;
            if(pf)
            {
                pf=pf->next;
                pl=pl->next;
            }
        }
        printf("该链表的中间节点为:%d",pl->num);
    }
}


void link_circle(pNODE head)
{
    pNODE pf,pl;
    if(head==NULL)
        printf("该链表为空!!无法判断!!
");
    else
    {
        pf=pl=head;
        pf=pf->next;
        while(pf)
        {
            pf=pf->next;
            pl=pl->next;
            if(pf==pl)
                printf("该链表有环!!
");
        }
        if(pf==NULL)
            printf("该链表中没有环!!
");
    }
}

void link_greme(pNODE *head1,pNODE *head2)
{
    pNODE p1,p2,pT;
    if(*head1==NULL&& *head2==NULL)
        printf("两个链表为空!!无法合并!!
");
    else
    {
        p1=*head1;
        p2=*head2;
        *head1=pT=NULL;
        while(p1 && p2)
        {
            if(p1->num <= p2->num )
            {
                if(pT== NULL)
                    *head1=pT=p1;
                else
                    pT=pT->next=p1;
                p1=p1->next;
            }
            else
            {
                if(pT== NULL)
                    *head1=pT=p2;
                else
                    pT=pT->next=p2;
                p2=p2->next;
            }
        }
        if(p1==NULL)
            pT->next=p2;
        if(p2==NULL)
            pT->next=p1;
    }
}

测试代码如下:

#include "head.h"
static void print(pNODE p)
{
    printf("%d  ",p->num);
}
int main(int argc,char *argv[])
{
    pNODE head1,head2;
    int size,num;
    head1=head2=NULL;
    srand((unsigned)time(NULL));
    printf("请输入链表长度:");
    scanf("%d",&size);
    //link_head(&head1,size);            //头插测试
    //link_last(&head1,size);            //尾插测试
    link_sortCreat(&head1,size);        //有序建立测试
    link_travers(head1,print);
    printf("
");
    link_sortCreat(&head2,size);
    link_travers(head2,print);
    printf("
");
    //printf("请输入一个值:");
    //scanf("%d",&num);
    //link_expand(&head1,num);            //增加新值测试
    //link_del(&head1,num);                //删除值测试
    //link_reverse(&head1);                //链表逆置
    //link_search(head1,num);            //查找倒数节点的数据
    //link_searchMID(head1);            //查找中间节点的数据
    //link_circle(head1);                //判断链表是否有环
    //link_greme(&head1,&head2);        //合并两个链表
    link_travers(head1,print);
    printf("
");
    system("pause");
    return 0;
}

在函数中，我们用一个函数指针实现了对链表的遍历，函数指针在后面的文章中会做简要介绍。