程序博客网 > 中国与大数据

单链表的创建算法

来源：互联网 发布：中国与大数据 编辑：程序博客网 时间：2024/06/11 01:16
    单链表的创建算法 http://blog.csdn.net/wp1603710463/article/details/50989500

       本文根据：清华大学出版社《数据结构与算法(C语言版)(第3版)》整理，详细请见书本。

       当一个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。

       单链表的示意图如下：

                                           
      Head指针为单链表的头指针，单链表L：L既是单链表的名字，也是其头指针。链表中的最后一个结点的指针域定义为空指针(NULL)。
      单链表的定义：

[plain] view plain copy
print?
  1. struct Node  
  2. {  
  3.   ElemType data;  
  4.   struct Node *next;  
  5. };  
  6. typedef struct Node LNode;  
  7. typedef struct Node *LinkedList;  
          单链表有带头结点和不带头结点之分。

       上图为没有头结点的单链表，下图为带有头结点的单链表：

                                         

   1.单链表的初始化，即建立一个空链表。

[plain] view plain copy
print?
  1. //不带头结点的单链表的初始化  
  2. void LinkedListInit1(LinkedList L)  
  3. {  
  4.   L=NULL;  
  5. }  
  6. //带头结点的单链表的初始化  
  7. void LinkedListInit2(LinkedList L)  
  8. {  
  9.   L=(LNode *)malloc(sizeof(LNode));  
  10.   if(L==NULL)  
  11.   {  
  12.     printf("申请空间失败！");  
  13.     exit(0);  
  14.   }  
  15.   L->next=NULL;  
  16. }  

    2.单链表的求表长操作

      单链表的求表长操作需要设定当前指针p和一个计数器j，初始时p指向链表中的第一个结点，p每向下移动一个结点时，j就加1，直到到达p链表的尾部。带头结点的链表，链表长度不包括头结点。
[plain] view plain copy
print?
  1. //带头结点的单链表求表长  
  2. int LinkedListLength(LinkedList L)  
  3. {  
  4.   LNode *p;            //p需要声明为LNode类型  
  5.   p=L->next;  
  6.   int j=0;  
  7.   while(p!=NULL)  
  8.   {  
  9.     j++;  
  10.     p=p->next;         //将p向下移动一个结点  
  11.   }  
  12.   return j;  
  13. }  

    3.单链表获取第i个结点元素的操作

     设定p为当前结点，初始时p指向链表的第一个结点，然后向下移动i，此时p所指向的元素就是需要查找的第i个结点元素。

[plain] view plain copy
print?
  1. //带头结点的单链表取元素操作  
  2. LinkedList LinkedListGetINode(LinkedList L, int i)  
  3. {  
  4.   LNode *p;  
  5.   p=L->next;  
  6.   int j=1;  
  7.   while((p!=NULL)&&(j<i))  
  8.   {  
  9.     p=p->next;  
  10.     j++;  
  11.   }  
  12.   return p;  
  13. }  

    4.单链表的定位操作

   

查找元素e第一次出现的位置。从链表的第一个结点开始，判断当前结点的值是否等于e，等于则返回该结点的指针，否则继续向后查找，直至到达链表的最后。

[plain] view plain copy
print?
  1. //带头结点的单链表定位操作  
  2. LNode LinkedListLocateE(LinkedList L, ElemType e)  
  3. {  
  4.   LNode *p;  
  5.   p=L->next;  
  6.   while((p!=NULL)&&(p->data!=e))  
  7.   {  
  8.     p=p->next;  
  9.   }  
  10.   return p;  
  11. }  

    5.单链表的插入操作

    在结点p之前插入一个新的结点q:对于不带头结点的单链表，结点p的位置有所不同，插入操作有以下两种情况：
    1)在链表的表头插入：
       (1)创建一个新的结点q。
       (2)将此结点的数据域赋值为e，并将它的next指针指向第一个结点，即L。
       (3)将L修改为指向新的结点q。
       操作示意图如下：

                                    
    2)在链表的中间插入
       (1)创建一个新的结点q。
       (2)将此结点的数据域赋值为e，并将它的next指针指向p。
       (3)查找到p的前驱结点pre。
       (4)将pre的next指针指向新创建的结点q。
      操作示意图如下：
                                             

[plain] view plain copy
print?
  1. //不带头结点的单链表的插入操作  
  2. void LinkedListInertQE1(LinkedList L, LinkedList p, ElemType e)  
  3. {  
  4.   q=(LNode *)malloc(sizeof(LNode));        //创建一个新的结点q  
  5.   if(q==NULL)  
  6.   {  
  7.     printf("申请空间失败！");  
  8.     exit(0);  
  9.   }  
  10.   q->data=e;  
  11.   
  12.   if(p==L)   //在表头插入  
  13.   {  
  14.     q->next=L;  
  15.     L=q;  
  16.   }  
  17.   else      //在表的中间进行插入  
  18.   {  
  19.     pre=L;  
  20.     while((pre!=NULL)&&(pre->next!=p))           //寻找p的前驱  
  21.        pre=pre->next;  
  22.   
  23.     q->next=pre->next;  
  24.     pre->next=q;  
  25.   }  
  26. }  
  27.   
  28. //带头结点的单链表的插入操作  
  29. void LinkedListInertQE2(LinkedList L, LinkedList p, ElemType e)  
  30. {  
  31.   q=(LNode *)malloc(sizeof(LNode));        //创建一个新的结点q  
  32.   if(q==NULL)  
  33.   {  
  34.     printf("申请空间失败！");  
  35.     exit(0);  
  36.   }  
  37.   q->data=e;  
  38.   
  39.   //插入新的结点  
  40.   pre=L;  
  41.   while((pre!=NULL)&&(pre->next!=p))           //寻找p的前驱  
  42.     pre=pre->next;  
  43.   
  44.   q->next=pre->next;  
  45.   pre->next=q;  
  46. }  

      6.单链表的删除操作

       删除链表中的某个元素e，如果e在链表中出现不止一次，将删除第一次出现的e，否则什么也不做。
       用p找到元素e所在的结点：
        1)p是链表中的第一个结点
            (1)将L指向p->next。
            (2)释放p。
         示意图如下：

                                       

         2)p是链表中的其他结点
            (1)找到p的前驱结点pre。
            (2)将pre->next指向p->next。
            (3)释放p。
         示意图如下：

                                                                 

[plain] view plain copy
print?
  1. //不带头结点的单链表的删除操作  
  2. void LinkedListDeleteQE1(LinkedList L, LinkedList p, ElemType e)  
  3. {  
  4.    pre=L;  
  5.    while((pre!=NULL)&&(pre->next->data!=e))      //查找元素e的前驱  
  6.        pre=pre->next;  
  7.    p=pre->next;  
  8.   
  9.    if(p!=NULL)                //找到需要删除的结点  
  10.    {  
  11.      if(p==L)                 //删除的是第一个结点  
  12.        L=p->next;  
  13.      else                     //删除的是其他结点  
  14.        pre->next=p->next;  
  15.      free(p);  
  16.    }  
  17. }  
  18. //带头结点的单链表的删除操作  
  19. void LinkedListDeleteQE2(LinkedList L, LinkedList p, ElemType e)  
  20. {  
  21.    pre=L;  
  22.    while((pre!=NULL)&&(pre->next->data!=e))      //查找元素e的前驱  
  23.        pre=pre->next;  
  24.    p=pre->next;  
  25.   
  26.    if(p!=NULL)                //找到需要删除的结点  
  27.    {  
  28.      pre->next=p->next;  
  29.      free(p);  
  30.    }  
  31. }  

        7.单链表的创建操作

        单链表的创建方法有两种：头插法和尾插法。
        头插法是将新增结点插入第一个结点之前，示意图如下：

                                          
        尾插法是将新增结点插入最后一个结点之后，示意图如下：

                                                       

[plain] view plain copy
print?
  1. //用头插法创建带头结点的单链表  
  2. void LinkedListCreateHeadL(LinkedList L, ElemType a[n])  
  3. {  
  4.   L=(LNode *)malloc(sizeof(LNode));  
  5.   if(L==NULL)  
  6.   {  
  7.     printf("申请空间失败！");  
  8.     exit(0);  
  9.   }  
  10.   L->next=NULL;  
  11.   
  12.   for(i=0; i<n; i++)  
  13.   {  
  14.     p=(LNode *)malloc(sizeof(LNode));  
  15.     if(p==NULL)  
  16.     {  
  17.       printf("申请空间失败！");  
  18.       exit(0);  
  19.     }  
  20.   
  21.     p->data=a[i];  
  22.     p->next=L->next;  
  23.     L->next=p;  
  24.   }  
  25. }  
  26. //用尾插法创建带头结点的单链表  
  27. void LinkedListCreateTailL(LinkedList L, ElemType a[n])  
  28. {  
  29.   L=(LNode *)malloc(sizeof(LNode));  
  30.   if(L==NULL)  
  31.   {  
  32.     printf("申请空间失败！");  
  33.     exit(0);  
  34.   }  
  35.   L->next=NULL;  
  36.   tail=L;         //设置尾指针，方便插入  
  37.   
  38.   for(j=0; j<n; j++)  
  39.   {  
  40.     p=(LNode *)malloc(sizeof(LNode));  
  41.     if(p==NULL)  
  42.     {  
  43.       printf("申请空间失败！");  
  44.       exit(0);  
  45.     }  
  46.   
  47.     p->data=a[j];  
  48.     p->next=NULL;  
  49.     tail->next=p;  
  50.     tail=p;  
  51.   }  
  52. }  

      8.单链表的合并操作

      首先设置3个指针pa、pb、pc, pa和pb分别指向链表La与Lb的当前待比较插入结点，pc指向链表Lc的最后一个结点。当pa->data≤pb->data时，将pa所指的结点插入到pc后面，否则就将pb所指的结点插入到pc后面。最后，当有一个表合并完，将另一个表剩余的结点全插入到pc。

[plain] view plain copy
print?
  1. //带头结点的单链表合并操作  
  2. void LinkedListMergeLaLb(LinkedList La, LinkedList Lb, LinkedList Lc)  
  3. {  
  4.   pa=La->next;  
  5.   pb=Lb->next;  
  6.   Lc=La;          //借用表La的头结点作为表Lc的头结点  
  7.   pc=Lc;  
  8.   
  9.   while((pa!=NULL)&&(pb!=NULL))  
  10.   {  
  11.     if(pa->data<=pb->data)  
  12.     {  
  13.       pc->next=pa;  
  14.       pc=pa;  
  15.       pa=pa->next;  
  16.     }  
  17.     else  
  18.     {  
  19.       pc->next=pb;  
  20.       pc=pb;  
  21.       pb=pb->next;  
  22.     }  
  23.   }  
  24.   if(pa!=NULL)  
  25.     pc=pa->next;  
  26.   else  
  27.     pc=pb->next;  
  28.   
  29.   free(pb);    //将Lb的表头结点释放  
  30. }  

 附录：

       程序实例：尾插法创建单链表

       首先在VS2010中新建Win32 控制台应用程序的项目LinkedList，结果如下：

                                               

       LinkedList.cpp : 定义控制台应用程序的入口点。

[cpp] view plain copy
print?
  1. // LinkedList.cpp : 定义控制台应用程序的入口点。  
  2.   
  3.     #include "stdafx.h"  
  4.   
  5.     #include<stdio.h>  
  6.     #include<stdlib.h>  
  7.     typedef struct node  
  8.     {  
  9.       int data;  
  10.       struct node *next;  
  11.     }*LinkedList;  
  12.   
  13.     LinkedList LinkedListCreateTailL(int a[8])  
  14.     {  
  15.       LinkedList p, L, tail;  
  16.       int i=0;  
  17.       L=(struct node*)malloc(sizeof(struct node));  
  18.       tail=L;  
  19.   
  20.       for(i=0; i<8; i++)  
  21.       {  
  22.         p=(struct node*)malloc(sizeof(struct node));  
  23.         p->data=a[i];  
  24.         tail->next=p;  
  25.         tail=p;  
  26.       }  
  27.       tail->next=NULL;  
  28.       return L;  
  29.     }  
  30.   
  31.     void LinkedListPrint(LinkedList L)  
  32.     {  
  33.       LinkedList p;  
  34.       p=L->next;  
  35.       while(p!=NULL)  
  36.       {  
  37.         printf("%d ",p->data);  
  38.         p=p->next;  
  39.       }  
  40.     }  
  41.   
  42.     void main()  
  43.     {  
  44.       int a[8], i;  
  45.       LinkedList L;  
  46.       printf("请输入8个列表元素，以回车结束：\n");  
  47.       for(i=0; i<8; i++)  
  48.       {  
  49.         scanf("%d", &a[i]);  
  50.       }  
  51.   
  52.       L=LinkedListCreateTailL(a);  
  53.       LinkedListPrint(L);  
  54.     }  
       Ctrl+F5执行以上cpp文件，程序运行截图：

                                           

阅读全文
0 0
中国与大数据 中国与大数据
原创粉丝点击
热门IT博客
solaris和linux的区别solaris和linux的区别
c语言优先级顺口溜c语言优先级顺口溜
淘宝模板代码大全
小学排列组合公式算法
matlab数组倒序
js 调用函数
c语言一维数组定义
淘宝旗舰店ugg很便宜
多益网络面试题
佛家讲究因果知乎
linux 完全卸载mysql
全境封锁ps4网络不好
java开发家具网上商城
vncmac链接windows
智能手机怎么下载软件
为什么起名字叫淘宝
弹奏音乐的软件
ye2系列电机绕组数据
win8.1安装java
最终幻想龙女捏脸数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 求书网手机版 书奇网 品书网手机版 下载书 书棋网 书旗 书旗网 书旗电子书下载txt免费下载 书旗网首页 书旗网作者专区 书旗破解版vip无限书豆 书旗网电子书下载txt免费下载 书旗免费下载 书旗破解版 书旗网免费阅读 书旗吧 书旗下载 免费书旗 下载书旗 书旗免费 书旗旧版 书旗破解版无限书豆 书旗旧版本下载 书旗破解 书旗app 书旗阅读 书旗阅读网 书旗阅读器 安卓下载 书旗读书软件下载 书旗网免费下载 书旗 破解版 书旗听书 书旗网网址 shu书旗 书旗网app shuqi 书祺 mianfeixiaoshuo 书琪 shuqixiaoshuo 书`

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里