［转］C语言之单向链表的创建插入删除等功能

最新推荐文章于 2023-03-22 15:27:10 发布
最新推荐文章于 2023-03-22 15:27:10 发布
阅读量862 收藏 1
点赞数
 

数据结构学习笔记之链表（C语言版）

分类： 技术交流 2015-01-04 18:34  183人阅读  评论(0)  收藏  举报
数据结构 c语言 线性表 单链表 合并

       链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表

由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元

素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。

       使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据（datafields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。链表可以在多种编程语言中实现。像Lisp和Scheme这样的语言的内建数据类型中就包含了链表的存取和操作。程序语言或面向对象语言，如C,C++和Java依靠易变工具来生成链表。


下面附上一段由C语言实现的一个完整的单链表，包括创建，插入，删除，查询，排序，输出，获取链表长度，求有序链表交集，求有序链表差集，合并两条链表（两种方法）等功能：

[html]  view plain copy
  1. #include<stdio.h>  
  2. #include<malloc.h>  
  3.   
  4. typedef struct Node{  
  5.     int data;  
  6.     struct Node* next;  
  7. }Node;  
  8.   
  9. Node* AddNum();                                  /*创建链表*/  
  10. void Insert(Node* head,int i,int a);             /*插入节点*/  
  11. void DeleteList(Node* head,int i);               /*删除节点*/  
  12. void SerachList(Node* head,int a);               /*查询数据*/  
  13. void SortList(Node* head);                       /*链表排序*/  
  14. Node* MergeList_old(Node* Ha,Node* Hb);          /*利用旧节点合并两条链表*/  
  15. Node* MergeList_New(Node* Ha,Node* Hb);          /*创建新节点合并两条链表*/  
  16. int GetListLength(Node* head);                   /*获取链表长度*/  
  17. Node* GetTheSame(Node* head1,Node* head2);       /*求有序链表交集*/  
  18. Node* GetTheDiffirent(Node* head1,Node* head2);  /*求有序链表链表差集*/  
  19. void PrintNum(Node* head);                       /*输出链表*/  
  20.   
  21. Node* AddNum(){  
  22.     char ans='y';  
  23.     Node* head=(Node*)malloc(sizeof(Node));  
  24.     Node* pc=(Node*)malloc(sizeof(Node));  
  25.     head=pc;  
  26.     while(ans!='n'&&ans!='N'){  
  27.         Node* temp1=(Node*)malloc(sizeof(Node));  
  28.         pc->next=temp1;  
  29.         pc=temp1;  
  30.         printf_s("begin to add the number.");  
  31.         scanf_s("%d",&pc->data);  
  32.         printf_s("do you want to countinue.");  
  33.         fflush( stdin );  
  34.         ans=getchar();  
  35.     }  
  36.     pc->next=NULL;  
  37.     return head;  
  38. }  
  39.   
  40. void Insert(Node* head,int i,int a){  
  41.     int ai=0;  
  42.     Node* temp=(Node*)malloc(sizeof(Node));  
  43.     temp=head;  
  44.     while(temp->next&&ai!=i-1){  
  45.         temp=temp->next;  
  46.         ai++;  
  47.     }  
  48.     if(ai!=i-1){  
  49.         printf_s("要插入的序号有误！！！");  
  50.     }  
  51.     else{  
  52.         Node* pc=(Node*)malloc(sizeof(Node));  
  53.         pc->data=a;  
  54.         pc->next=temp->next;  
  55.         temp->next=pc;  
  56.     }  
  57. }  
  58.   
  59. void DeleteList(Node* head,int i){  
  60.     int ai=0;  
  61.     int a;  
  62.     Node* pc=(Node*)malloc(sizeof(Node));  
  63.     Node* qc=(Node*)malloc(sizeof(Node));  
  64.     pc=head;  
  65.     while(pc->next&&ai!=i-1){  
  66.         pc=pc->next;  
  67.         ai++;  
  68.     }  
  69.     if(ai!=i-1||!pc->next)  
  70.         printf_s("错误的序号！！！");  
  71.     else if(ai=i-1&&!pc->next)  
  72.         printf_s("错误的序号！！！");  
  73.     else{  
  74.         qc=pc->next;  
  75.         if(!qc->next){  
  76.             a=qc->data;  
  77.             free(qc);  
  78.             printf_s("you delete the %d\n",a);  
  79.         }  
  80.         else{  
  81.             pc->next=qc->next;  
  82.             a=qc->data;  
  83.             free(qc);  
  84.             printf_s("you delete the %d\n",a);  
  85.         }  
  86.     }  
  87. }  
  88.   
  89. void SerachList(Node* head1,int a){  
  90.     int i=0;  
  91.     Node* temp=(Node*)malloc(sizeof(Node));  
  92.     temp=head1;  
  93.     while(temp->next&&temp->data!=a){  
  94.         temp=temp->next;  
  95.         i++;  
  96.     }  
  97.     if(!temp->next)  
  98.         printf_s("没有此数据！！！");  
  99.     else  
  100.         printf_s("在序号为%d的位置.",i);  
  101. }  
  102.   
  103. void SortList(Node* head){  
  104.     Node* pa=(Node*)malloc(sizeof(Node));  
  105.     Node* pc=(Node*)malloc(sizeof(Node));  
  106.     Node* temp=(Node*)malloc(sizeof(Node));  
  107.     pa=head->next;  
  108.     while(pa){  
  109.         pc=pa->next;  
  110.         while(pc){  
  111.             if(pa->data>pc->data){  
  112.                  temp->data=pa->data;  
  113.                  pa->data=pc->data;  
  114.                  pc->data=temp->data;  
  115.             }  
  116.             pc=pc->next;  
  117.         }  
  118.         pa=pa->next;  
  119.     }  
  120. }  
  121.   
  122. Node* MergeList_old(Node* Ha,Node* Hb){  
  123.     Node* pa=(Node*)malloc(sizeof(Node));  
  124.     Node* pb=(Node*)malloc(sizeof(Node));  
  125.     Node* pc=(Node*)malloc(sizeof(Node));  
  126.     pa=Ha->next;  
  127.     pb=Hb->next;  
  128.     pc=Ha;  
  129.     while(pa&&pb){  
  130.         if(pa->data<=pb->data){  
  131.             pc->next=pa;  
  132.             pc=pa;  
  133.             pa=pa->next;  
  134.         }else{  
  135.             pc->next=pb;  
  136.             pc=pb;  
  137.             pb=pb->next;  
  138.         }  
  139.     }  
  140.     pc->next=pa?pa:pb;  
  141.     free(Hb);  
  142.     return Ha;  
  143. }  
  144.   
  145. Node* MergeList_New(Node* Ha,Node* Hb){  
  146.     Node* pa=(Node*)malloc(sizeof(Node));  
  147.     Node* pb=(Node*)malloc(sizeof(Node));  
  148.     Node* pc=(Node*)malloc(sizeof(Node));  
  149.     Node* head=(Node*)malloc(sizeof(Node));  
  150.     pa=Ha->next;  
  151.     pb=Hb->next;  
  152.     head=pc;  
  153.     while(pa||pb){  
  154.         Node* tp=(Node*)malloc(sizeof(Node));  
  155.         pc->next=tp;  
  156.         pc=tp;  
  157.         if(!pa){  
  158.             pc->data=pb->data;  
  159.             pb=pb->next;  
  160.         }  
  161.         else if(!pb){  
  162.             pc->data=pa->data;  
  163.             pa=pa->next;  
  164.         }  
  165.         else if(pa->data==pb->data){  
  166.             pc->data=pa->data;  
  167.             pa=pa->next;  
  168.             pb=pb->next;  
  169.         }  
  170.         else if(pa->data<pb->data){  
  171.             pc->data=pa->data;  
  172.             pa=pa->next;  
  173.         }  
  174.         else{  
  175.             pc->data=pb->data;  
  176.             pb=pb->next;  
  177.         }  
  178.     }  
  179.     pc->next=NULL;  
  180.     return head;  
  181. }  
  182.   
  183. int GetListLength(Node* head){  
  184.     int i=0;  
  185.     Node* temp=(Node*)malloc(sizeof(Node));  
  186.     temp=head;  
  187.     while(temp->next){  
  188.         i++;  
  189.         temp=temp->next;  
  190.     }  
  191.     return i;  
  192. }  
  193.   
  194. Node* GetTheSame(Node* head1,Node* head2){  
  195.     Node* pa=(Node*)malloc(sizeof(Node));  
  196.     Node* pb=(Node*)malloc(sizeof(Node));  
  197.     Node* pc=(Node*)malloc(sizeof(Node));  
  198.     pa=head1->next;  
  199.     pb=head2->next;  
  200.     pc=head1;  
  201.     while(pa&&pb){  
  202.         if(pa->data==pb->data){  
  203.             pc=pa;  
  204.             pa=pa->next;  
  205.         }  
  206.         else if(pa->data<pb->data){  
  207.             pc->next=pa->next;  
  208.             free(pa);  
  209.             pa=pc->next;  
  210.         }  
  211.         else  
  212.             pb=pb->next;  
  213.     }  
  214.     pc->next=NULL;  
  215.     while(pa){  
  216.         pc=pa;  
  217.         pa=pa->next;  
  218.         free(pc);  
  219.     }  
  220.     pb=head2;  
  221.     while(pb){  
  222.         pc=pb;  
  223.         pb=pb->next;  
  224.         free(pc);  
  225.     }  
  226.     return head1;  
  227. }  
  228.   
  229. Node* GetTheDiffirent(Node* head1,Node* head2){  
  230.     Node* pa=(Node*)malloc(sizeof(Node));  
  231.     Node* pb=(Node*)malloc(sizeof(Node));  
  232.     Node* pc=(Node*)malloc(sizeof(Node));  
  233.     pa=head1->next;  
  234.     pb=head2->next;  
  235.     pc=head1;  
  236.     while(pa&&pb){  
  237.         if(pa->data==pb->data){  
  238.             pc->next=pa->next;  
  239.             free(pa);  
  240.             pa=pc->next;  
  241.         }  
  242.         else if(pa->data<pb->data){  
  243.             pc=pa;  
  244.             pa=pa->next;  
  245.         }  
  246.         else  
  247.             pb=pb->next;  
  248.     }  
  249.     pb=head2;  
  250.     while(pb){  
  251.         pc=pb;  
  252.         pb=pb->next;  
  253.         free(pc);  
  254.     }  
  255.     return head1;  
  256. }  
  257.   
  258. void PrintNum(Node* head){  
  259.     Node* temp;  
  260.     temp=head;  
  261.     while(temp->next){  
  262.         printf_s("%d",temp->next->data);  
  263.         temp=temp->next;  
  264.     }  
  265. }  
[html]  view plain copy
  1. int main()  
  2. {  
  3.     Node* head1;  
  4.     Node* head2;  
  5.     Node* head3;  
  6.     head3=NULL;  
  7.     head1=AddNum();  
  8.     SortList(head1);  
  9.     head2 = AddNum();  
  10.     SortList(head2);  
  11.     head3 = MergeList_old(head1, head2);  
  12.     PrintNum(head3);  
  13.     printf_s("\n");  
  14.     return 0;  
  15. }  
Halo-rccc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现单向链表的创建、插入、删除——————墨白
正直 的博客
03-15 2996
我们今天来温习单向链表的种种操作。 1.普通的链表创建 对于创建链表有一个很重要的思想。那就是每次一定只创建一个节点。这样创建链表的难度就被大大降低了。 我们的算法思维是这样的。所谓创建，不过是把新的节点插入到链表尾部。所以我们做的事情很简单，只需要两步：1.找到尾节点2.插入新节点 //我们来做链表 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt;...
c语言单链表的创建、插入、删除
qq_29673441的博客
07-13 4134
由于之前的下位机开发要求比较低，很少使用链表，后来换了份工作，跟另外一个同事共同开发一个主控程序，链表成为了最基本的数据结构，所以花了一段时间对链表进行了比较认真的学习，以下内容为个人对链表的一些理解。 1：链表的结构 链标的单位为节点，节点包含数据及指向下一个节点的地址。 2：链表的创建 将各个节点按上图的结构串联在一起 3：链表的插入 4、删除一个节点 5
C语言单向链表的建立(具体到代码实现)
轮子工厂
04-18 1万+
1.为什么要用到链表 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。 我们希望构造动态...
C语言数据结构 单链表的建立、遍历、查找、插入和删除操作
追求。
04-26 1万+
链表（Linked List）是一种物理存储单元上非连续、非顺序的数据结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（node，链表中每一个元素称为结点）组成，每一次为一个结构体 动态分配的内存空间，可称之为一个结点，每个结点之间可以是不连续的，但结点内是连续的。结点个数是不受限定的，可以随时删改，这是与数组相比的优点。.........
c语言实现单链表的创建（完整版）
qq_44858403的博客
05-25 1万+
使用c语言实现单链表是考研的重点。但是如何实现却是一个难点。下面是我写的一个简单的创建单链表的代码。 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef struct node{ int data; struct node *next; }LinkList; //结构体的定义 LinkList *create_Link(){ //创建单链表的主要代码（尾插法建立单链表） LinkLi
数据结构——单链表 创建 清空 插入 删除 查询 输出 完整源码
m0_61628700的博客
02-26 7396
完整代码在最后 一.单链表基本操作 1.初始化 1）创建结构体，储存节点的数据+指针域； 2）创建指向结构体的指针； 3）用结构体定义单链表； 4）初始化链表头节点：为头节点开辟内存； 5）判断内存是否开辟成功； 6）头节点的指针域置空，使链表长度为0。 typedef struct Node//1 { ElemType data; struct Node *next; }Node; typedef struct Node *LinkList;//2 Status Init...
C语言单向链表看这一个就够了（包含链表的建立、输出、删除、插入、释放附代码和运行结果）
m0_57148596的博客
03-22 2433
今天凌晨接触结构体时，接触了结构体指针，当时感觉并没有什么鸟用，于是我百度了下，发现其是构建链表的一种非常常用的工具。这里其实有个很容易让编程小白容易误解的地方，即搞混结构体指针和结构体中的指针。结构体指针，指的是结构体的变量，而结构体中的指针是在构建结构体时定义的一个成员，这就是它们的最大区别。于是为了更加了解结构体指针的应用场景，我查看单项链表的相关视频直到凌晨4点，终于小有所成，只是头发也跟着少了几根。结尾附运行结果。最后我们尝试对上面5个步骤放进int main（）进行运行吧。//主函数。
C语言之单向链表详解及实例代码
12-31
1，单向链简洁。...根据示例代码中的例子，完成单向链表(single linked list)中的以字符串为数据的链表的插入、删除以及查找，并支持单向链表的反转； 3，代码实现。 #include #include <math.h>
单向链表结点的逐个删除-C语言教程
07-26
每敲一次代码都会有新的收获，基本功不扎实啥也干不了。单向链表的插入，删除，创建，遍历是数据结构的基本操作。里边的算法值得学习。下面我们就来学习一下单向链表结点的逐个删除的方法。
C语言实现单向链表的创建、插入，删除节点，和2个链表合并
12-10
本文将详细讲解如何使用C语言在Microsoft Visual C++ 6.0环境下实现单向链表的创建、插入、删除节点以及两个链表的合并。 一、单向链表的基本概念 单向链表是一种线性数据结构，每个元素（称为节点）包含两部分：...
c语言实现单向链表.
01-05
本文将深入探讨如何使用C语言来实现单向链表，并扩展到实现双向链表的“增删改查显”功能。 首先，让我们了解链表的基本概念。链表是一种线性数据结构，与数组不同，它在内存中不是连续存储的。每个链表节点包含两...
C++实现单向链表的“建立”，“插入”，“删除”，“输出”
给我加个蛋再走
07-17 860
直接上代码 #include &lt;iostream&gt; using namespace std; struct data { int number; data *next; }; data *head=NULL; //定义一个全局变量的头指针 void create() //链表创造函数 { data *p;data *s;int num; cout&l...
链表的建立、输出、删除、插入
m0_63666897的博客
05-21 2671
在主函数中实现多个节点的插入与删除 本代码的背景是输入学号，成绩，以0，0，终止，后输入删除节点个数，删除者学号，再然后输入添加节点个数，添加者的学号，成绩。 小编初学写的比较复杂，各位大佬还请轻点喷 代码如下： #include<bits/stdc++.h> using namespace std; #define LEN sizeof(struct student) int n; struct student { long long int num; double score.
C语言数据结构篇——单链表的创建，插入，节点删除和打印等操作
Demo不是emo的博客
01-30 5971
线性表的顺序存储称为顺序表，而链表就是线性表的链式存储，而链表相对于顺序表的一个特点就是可以实现存储空间的动态管理，另一个就是每个节点的地址可能是不连续的，所以可以提高空间利用率，并且每个节点都由数据域和指针域构成。如果每个节点中只有指向后继节点的指针，那这就是我今天要分享的内容——单链表。 链表有很多种写法，有很多人定义一个节点结构体，又有部分人喜欢像顺序表一样定义一个头结点还有各种各样的写法，而我比较喜欢定义一个头结点的来保存链表的信息。那简单理解也就到这里了，下面给大家写一下以便大家可以更加直观的理
c语言单向链表的创建和删除,c语言实现，单向链表，创建、插入、输出、删除、清空...
weixin_42378374的博客
05-23 270
#include#includetypedefstructnode{intvalue;structnode*next;}NODE,*NODEP;//新建空链表NODEPcreate(){NODEPp;p=(NODEP)malloc(sizeof(NODE));p->next=NULL;}//插入，头插、尾插voidinsert(NODEPhead,intd...
单向链表的创建、输出、插入、删除
weixin_30332705的博客
07-29 141
#include <iostream> using namespace std; struct Node { int id; int score; struct Node *next; }*list_head; void scan() { int id; Node *list_temp; ...
建立一个单向链表的步骤(C语言)
热门推荐
qq_49175846的博客
05-17 2万+
建立一个单向链表的步骤要点总结
单链表的4种简单操作——建立、输出、删除、插入
qq_61476828的博客
10-12 945
参阅于谭版C语言程序设计（第五版）第9章第9题 此题的建立和输出操作延用教材中例题提到过的算法，而删除和插入操作均为个人想法，由于此时还未系统性学习数据结构和算法，可能并不是最优的算法，待日后学习数据结构和算法后再来改进。 建立 我们可以定义一个creat函数来实现，参数列表为空，返回值类型为结点（结构体）指针，通过调用此函数得到所建立链表的头指针。 其算法的大致思想是通过定义两个结点指针p1和p2，p1不断的指向我们新创建的结点，p2不断的指向链表表尾结点（或者说不断的更新表尾...
单链表的创建及插入，删除，查找数据
qq_51825761的博客
04-22 3145
创建链表，插入数据，查找数据，删除数据 下面个代码是看c和指针写出来的，但我感觉有点问题！书上最后一个代码是这样给出的，他想传递的应该是链表第一个结点的地址，而不是头结点的地址，否则头结点是没数据的，即不应该与new_value比较。然而，传递了第一个结点的地址，insert函数必然会移动linkp的位置，因为没有另外的变量存储数据，那么问题来了，在主函数中，输出数据的时候，怎么从第一个数据开始输出，这儿的头结点的位置已经移动到new_value的前面一个节点了。所以，妾以为，用一个变量代替linkp更
C语言实现单向链表的创建及数据的删除
最新发布
04-04
本文将介绍如何使用C语言实现单向链表的创建和数据的删除。 1. 创建单向链表 创建单向链表需要定义一个节点结构体，包含数据成员和指向下一个节点的指针。然后通过循环动态分配节点内存并将节点按顺序连接起来，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值