[转载]C语言链表的建立、插入和删除
来源：博客园
- 链表的建立、插入和删除数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，经常会造成一定存储空间的浪费。我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。7.4.1 单链表图7 - 3是单链表的结构。单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。看一下链表节点的数据结构定义：struct node{struct node *p;} ;在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。在链表节点的数据结构中，非常非凡的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。o 单链表的创建过程有以下几步：1 ) 定义链表的数据结构。2 ) 创建一个空表。3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新节点接到表尾。5 ) 判定一下是否有后续节点要接入链表，若有转到3 )，否则结束。o 单链表的输出过程有以下几步1) 找到表头。2) 若是非空表，输出节点的值成员，是空表则退出。3 ) 跟踪链表的增长，即找到下一个节点的地址。4) 转到2 )。[例7-5] 创建一个存放正整数（输入- 9 9 9做结束标志）的单链表，并打印输出。#include &stdlib.h& /包*含ma l l o c ( ) 的头文件*/#include &stdio.h&struct node /*链表节点的结构* /{struct node *} ;m a i n ( ){struct node *creat(); / *函数声明* /void print();struct node * / * 定义头指针* /head=NULL;/*建一个空表*/head=creat(head);/*创建单链表*/print(head);/*打印单链表*/}/******************************************/struct node*creat(structnode*head)函/数*返回的是与节点相同类型的指针*/ 
{struct node*p1,*p2;p1=p2=(structnode*)malloc(sizeof(structnode));申请/*新节点*/scanf("%d",&p1-&num);/*输入节点的值*/p1-&next=NULL;/*将新节点的指针置为空*/while(p1-&num&0)/*输入节点的数值大于0*/{if(head==NULL)head=p1;/*空表，接入表头*/elsep2-&next=p1;/*非空表，接到表尾*/p2=p1;p1=(structnode*)malloc(sizeof(structnode));申/请*下一个新节点*/scanf("%d",&p1-&num);/*输入节点的值*/}/*返回链表的头指针*/}/*******************************************/void print(struct node*head)输/*出以head为头的链表各节点的值*/{struct node *temp=/*取得链表的头指针*/while(temp!=NULL)/*只要是非空表*/{printf("%6d",temp-&num);/*输出链表节点的值*/temp=temp-&/*跟踪链表增长*/}}在链表的创建过程中，链表的头指针是非常重要的参数。因为对链表的输出和查找都要从链表的头开始，所以链表创建成功后，要返回一个链表头节点的地址，即头指针。
- 链表的建立、插入和删除7.4.2 单链表的插入与删除在链表这种非凡的数据结构中，链表的长短需要根据具体情况来设定，当需要保存数据时向系统申请存储空间，并将数据接入链表中。对链表而言，表中的数据可以依此接到表尾或连结到表头，也可以视情况插入表中；对不再需要的数据，将其从表中删除并释放其所占空间，但不能破坏链表的结构。这就是下面将介绍的链表的插入与删除。1. 链表的删除在链表中删除一个节点，用图7 - 4描述如下：[例7-6] 创建一个学生学号及姓名的单链表，即节点包括学生学号、姓名及指向下一个节点的指针，链表按学生的学号排列。再从键盘输入某一学生姓名，将其从链表中删除。首先定义链表的结构：struct从图7 - 4中看到，从链表中删除一个节点有三种情况，即删除链表头节点、删除链表的中间节点、删除链表的尾节点。题目给出的是学生姓名，则应在链表中从头到尾依此查找各节点，并与各节点的学生姓名比较，若相同，则查找成功，否则，找不到节点。由于删除的节点可能在链表的头，会对链表的头指针造成丢失，所以定义删除节点的函数的返回值定义为返回结构体类型的指针。struct node *delet(head,pstr)以/*he a d 为头指针，删除ps t r 所在节点*/struct node *char *{struct node *temp,*p;t e m p = / * 链表的头指针* /if (head==NULL) / *链表为空* /printf(" List is null! ");else /*非空表* /{t e m p =while (strcmp(temp-&str,pstr)!=0&&temp-&next!=NULL)/ * 若节点的字符串与输入字符串不同，并且未到链表尾* /{p =t e m p = t e m p - & / * 跟踪链表的增长，即指针后移* /}if(strcmp(temp-&str,pstr)==0 ) / *找到字符串* /{if(temp==head) { / * 表头节点* /printf("delete string :%s ",temp-&str);h e a d = h e a d - &f r e e ( t e m p ) ; / *释放被删节点* /}e l s e{p-&next=temp-& /表*中节点*/printf("delete string :%s ",temp-&str); 
f r e e ( t e m p ) ;}}else printf(" no find string! ");没/找* 到要删除的字符串*/}r e t u r n ( h e a d ) ; / *返回表头指针* /}2. 链表的插入首先定义链表的结构：struct{ /*学生学号* /char str[20]; /*姓名* /struct node *} ;在建立的单链表中，插入节点有三种情况，如图7 - 5所示。插入的节点可以在表头、表中或表尾。假定我们按照以学号为顺序建立链表，则插入的节点依次与表中节点相比较，找到插入位置。由于插入的节点可能在链表的头，会对链表的头指针造成修改，所以定义插入节点的函数的返回值定义为返回结构体类型的指针。节点的插入函数如下：struct node *insert(head,pstr,n) / *插入学号为n、姓名为p s t r 的节点* /struct node * / *链表的头指针* /char * {struct node *p1,*p2,*p3;p1=(struct node*)malloc(sizeof(struct node))分;配/*一个新节点*/s t r c p y ( p 1 - & s t r , p s t r ) ; / * 写入节点的姓名字串* /p 1 - & n u m = / * 学号* /p 2 =if (head==NULL) / * 空表* /{head=p1; p1-&next=NULL;/ *新节点插入表头* /}e l s e{ /*非空表* /while(n&p2-&num&&p2-&next!=NULL)/ *输入的学号小于节点的学号，并且未到表尾* /{p 3 = p 2 ;p 2 = p 2 - & / * 跟踪链表增长* /}if (n&=p2-&num) / *找到插入位置* /if (head==p2) / * 插入位置在表头* /{h e a d = p 1 ;p 1 - & n e x t = p 2 ;}e l s e{ /*插入位置在表中* /p 3 - & n e x t = p 1 ;p 1 - & n e x t = p 2 ;}e l s e{ /*插入位置在表尾* /p 2 - & n e x t = p 1 ;p 1 - & n e x t = N U L L ;}}r e t u r n ( h e a d ) ; / * 返回链表的头指针* /}
- 链表的建立、插入和删除3. 实例[例7 - 7 ]创建包含学号、姓名节点的单链表。其节点数任意个，表以学号为序，低学号的在前，高学号的在后，以输入姓名为空作结束。在此链表中，要求删除一个给定姓名的节点，并插入一个给定学号和姓名的节点。# include "stdlib.h"# include "malloc. h"struct node /*节点的数据结构* /{char str[20];struct node *} ;/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * /main( ){/ *函数声明* /struct node *creat();struct node *insert();struct node *delet();void print( );struct node *char str[20];head=NULL; /*做空表* /head=creat (head); / *调用函数创建以head 为头的链表* /p r i n t ( h e a d ) ；/ *调用函数输出节点* /printf(" input inserted num,name: ");gets(str); /*输入学号* /n=atoi (str);gets(str); /*输入姓名* /head=insert (head, str, n); 将/*节点插入链表*/print (head)； / *调用函数输出节点*/printf(" input deleted name: ");gets(str); /*输入被删姓名* /head=delet(head,str); /调*用函数删除节点*/print (head); /*调用函数输出节点* /}/ * * * * * * * * * * * * * * * * * * * * * * // * * * 创建链表* * * * * * * * * * * * / 
struct node *creat(struct node *head){char temp[30];struct node *pl,*p2;pl=p2=(struct node*) malloc(sizeof(struct node));printf ("input num, name: ;")printf("exit:double times Enter! ");g e t s ( t e m p ) ;gets (p1-&str);pl-&num=atoi (temp);p l - & n e x t = N U L L ;while (strlen (pl-&str)&0{if (head==NULL) head=pl；else p2-&next=p1;P 2 = p l ；pl=(struct node *)malloc(sizeof(struct node));printf ("input num, name: ");printf("exit:double times Enter! ");g e t s ( t e m p ) ;gets(pl -&str);p1-&num=atoi (temp);P 1 - & n e x t = N U L L ;}}/ * * * * * * * * * * * * * * * * * * * * // * * * * * * * * * * 插入节点* * * * * * * * * * /struct node *insert (head, pstr,n);struct node *char *{struct node *pl,*p2,*p3;p1=(struct node*)malloc(sizeof(struct node));strcpy (p1-&str, pstr);p 1 - & n u m =p 2 =i f ( h e a d = = N U L L ){h e a d = p l - & n e x t = N U L L ;}e l s e{while (n&p2-&num&&p2-&next!=NULL){p 3 = P 2p 2 = p 2 - &}if (n&=p2-&num)if (head==p2){h e a d =p l - & n e x t = p 2 ;}else{p 3 - & n e x t =p l - & n e x t = p 2 ;}else{p 2 - & n e x t =p l - & n e x t = N U L L ;}}r e t u r n ( h e a d ) ;}/ * * * * * * * * * * * * * * * * * * * * * * * * * // * * * * * 删除节点* * * * * * * * * * * * * /struct node *delet (head, pstr)struct node *char *{struct node *temp,*p;t e m p =if (head==NULL)printf(" List is null! ");else{t e m p =while (strcmp(temp-&str,pstr)!=O&&temp-&next!=NULL){p =t e m p = t e m p - & n e x t ,}i f ( s t r c m p ( t e m p - & s t r , p s t r ) = = 0 ){if (temp== head){h e a d = h e a d - &f r e e ( t e m p ) ;}else{p-&next =temp-&printf("delete string :%s ",temp-&str);f r e e ( t e m p ) ;}}else printf(" no find string! ");}return(head);}/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // * * * * * * * * * * 链表各节点的输出* * * * * * * * * * /void print (struct node *head){struct node *t e m p =printf(" output strings: ");while (temp!=NULL){p r i n t f ( " \ n % d - - - - % s \ n " , t e m p - & n u m ，t e m p - & s t r ) ；t e m p = t e m p - & n e x t ；}}
免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动职友集：让就业决策更聪明7804人阅读
Unix C及C高阶编程（12）
别的不多说了，图比文字更具有描述力，自己看！
一直都把堆栈放一起，所以很多人会误以为他们的组合是一个词语，就像“衣服”一样简单，其实不然，今天在下就将最近学习总结的一些与大家分享。&
&&&&&一个由C/C++编译的程序占用的内存分为以下几个部分：
&&&&& 1、栈区（stack）：又编译器自动分配释放，存放函数的参数值，局部变量的值等，其操作方式类似于数据结构的栈。
&&&&& 2、堆区（heap）：一般是由程序员分配释放，若程序员不释放的话，程序结束时可能由OS回收，值得注意的是他与数据结构的堆是两回事，分配方式倒是类似于数据结构的链表。
&&&& 3、全局区（static）：也叫静态数据内存空间，存储全局变量和静态变量，全局变量和静态变量的存储是放一块的，初始化的全局变量和静态变量放一块区域，没有初始化的在相邻的另一块区域，程序结束后由系统释放。
&&& 4、文字常量区：常量字符串就是放在这里，程序结束后由系统释放。
&&& 5、程序代码区：存放函数体的二进制代码。
&&&&堆和栈的区别：
&&&&& 一、由以上综述就可以得知，他们程序的内存分配方式不同。
&&&&& 二、申请和响应不同：
&&&& 1、申请方式：stack由系统自动分配，heap需要程序员自己申请，C中用函数malloc分配空间，用free释放，C++用new分配，用delete释放。
&&&& 2、申请后系统的响应：
&&&&& 栈：只要栈的剩余空间大于所申请的空间，体统将为程序提供内存，否则将报异常提示栈溢出。
&&&&&&堆：首先应该知道操作系统有一个记录内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请的空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete或free语句就能够正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会将多余的那部分重新放入空闲链表中。
&&&& 三、 申请的大小限制不同：
&&& &栈：在windows下，栈是向低地址扩展的数据结构，是一块连续的内存区域，栈顶的地址和栈的最大容量是系统预先规定好的，能从栈获得的空间较小。
&&& 堆：堆是向高地址扩展的数据结构，是不连续的内存区域，这是由于系统是由链表在存储空闲内存地址，自然堆就是不连续的内存区域，且链表的遍历也是从低地址向高地址遍历的，堆得大小受限于计算机系统的有效虚拟内存空间，由此空间，堆获得的空间比较灵活，也比较大。
&&&& 四、申请的效率不同：
&&&& 栈：栈由系统自动分配，速度快，但是程序员无法控制。
&&&& 堆：堆是有程序员自己分配，速度较慢，容易产生碎片，不过用起来方便。
&&& &五、堆和栈的存储内容不同：
&&&& 栈：在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令的地址，然后是函数的各个参数，在大多数的C编译器中，参数是从右往左入栈的，当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令。
&&&& 堆：一般是在堆得头部用一个字节存放堆得大小，具体内容由程序员安排。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：1552214次
积分：10552
积分：10552
排名：第1806名
原创：109篇
转载：10篇
评论：1500条
文章：26篇
阅读：81815
(1)(4)(1)(1)(1)(2)(3)(1)(2)(6)(1)(1)(5)(2)(2)(1)(2)(29)(25)(1)(3)(2)(1)(1)(2)(9)(10)C++实现单链表常用功能(不带头结点)
来源：博客园
自己用C++实现最基本的数据结构之一单链表，常用功能都有了，可以很方便的进行栈和队列功能的扩展。另外，感谢老婆花了一个晚上帮忙测试，能够想到的场景都经过单元测试。下面是代码。
singlelist.h：链表结点数据元素类型ELEMTYPE，重载了运算符==,=,&,&，方便运算。

1 #ifndef SINGLE_LIST_H
2 #define SINGLE_LIST_H
3 #include &stdlib.h&
4 #include &stdio.h&
6 enum
RET_SUCCESS = 0,
RET_FAILURE = -1
 10 };
 11 
 12 enum
 13 {
 14
TRUE = 1,
 15
FALSE = 0
 16 };
 17 
 18 typedef struct sElemType
 19 {
 20
int m_iD
 21
sElemType& operator= (const sElemType& elem)
 22
if(this == &elem)
 24
return *this;
 26
this-&m_iData = elem.m_iD
 28
return *this;
 29
}
 30 
 31
int operator& (const sElemType& elem)
 32
if(this-&m_iData & elem.m_iData)
 34
return TRUE;
 36
return FALSE;
 38
}
 39 
 40
int operator& (const sElemType& elem)
 41
if(this-&m_iData & elem.m_iData)
 43
return TRUE;
 45
return FALSE;
 47
}
 48 
 49
int operator== (const sElemType& elem)
 50
if(this-&m_iData == elem.m_iData)
 52
return TRUE;
 54
return FALSE;
 56
}
 57 
 58
void print()
 59
printf("%d",m_iData);
 61
}
 62 } ELEMTYPE;
 63 
 64 typedef struct ListNode
 65 {
 66
ELEMTYPE
 67
ListNode*
 68 } ListN
 69 
 70 //头部插入
 71 int insertAtHead(ListNode* &head,ELEMTYPE& elem);
 72 
 73 //尾部插入
 74 int insertAtTail(ListNode* &head,ELEMTYPE& elem);
 75 
 76 //头部删除
 77 int deleteHead(ListNode* &head,ELEMTYPE& elem);
 78 
 79 //尾部删除
 80 int deleteTail(ListNode* &head,ELEMTYPE& elem);
 81 
 82 //获取头结点元素
 83 int getHead(ListNode* &head,ELEMTYPE& elem);
 84 
 85 //获取尾结点元素
 86 int getTail(ListNode* &head,ELEMTYPE& elem);
 87 
 88 //在相等元素后插入
 89 int insertNode(ListNode* &head,ELEMTYPE& elem);
 90 
 91 //删除相应元素
 92 int deleteNode(ListNode* &head,ELEMTYPE& elem);
 93 
 94 //在相应位置插入
 95 int insertLocation(ListNode* &head,int iLocation,ELEMTYPE& elem);
 96 
 97 //删除相应位置元素
 98 int deleteLocation(ListNode* &head,int iLocation,ELEMTYPE& elem);
 99 
100 //链表长度
101 int getListLength(ListNode* &head);
102 
103 //查找元素在链表中位置
104 int search(ListNode* &head,ELEMTYPE& elem,int &iLocation);
105 
106 //逆序
107 int reverse(ListNode* &head);
108 
109 //排序
110 void sort(ListNode* &head);
111 
112 //是否空
113 int isEmpty(ListNode* &head);
114 
115 //清除所有结点
116 int clearAll(ListNode* &head);
117 
118 //打印结点信息
119 int DisplayList(ListNode* &head);
120 #endif

 
singlelist.cpp:

1 #include "singlelist.h"
3 int insertAtHead(ListNode* &head,ELEMTYPE& elem)
ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
pNode-&data =
if(head == NULL)
head = pN
 10
pNode-&next = NULL;
 11
return RET_SUCCESS;
 12
pNode-&next =
 14
head = pN
 15
return RET_SUCCESS;
 16 }
 17 
 18 int insertAtTail(ListNode* &head,ELEMTYPE& elem)
 19 {
 20
ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
 21
pNode-&data =
 22
if(head == NULL)
 23
head = pN
 25
pNode-&next = NULL;
 26
return RET_SUCCESS;
 27
ListNode* p =
 29
while(NULL != p-&next)
 30
p = p-&
 32
p-&next = pN
 34
pNode-&next = NULL;
 35
return RET_SUCCESS;
 36 }
 37 
 38 int deleteHead(ListNode* &head,ELEMTYPE& elem)
 39 {
 40
if(NULL == head)
 41
return RET_FAILURE;
 43
ListNode* pNode =
 45
head = head-&
 46
elem = pNode-&
 47
free(pNode);
 48
return RET_SUCCESS;
 49 }
 50 
 51 int deleteTail(ListNode* &head,ELEMTYPE& elem)
 52 {
 53
if(NULL == head)
 54
return RET_FAILURE;
 56
if(NULL == head-&next)
 58
elem = head-&
 60
free(head);
 61
head = NULL;
 62
return RET_SUCCESS;
 63
ListNode* p =
 65
ListNode* q =
 66
while(NULL != p-&next)
 67
q =
 69
p = p-&
 70
elem = p-&
 72
q-&next = NULL;
 73
free(p);
 74
return RET_SUCCESS;
 75 }
 76 
 77 int DisplayList(ListNode* &head)
 78 {
 79
if(NULL == head)
 80
return RET_FAILURE;
 82
ListNode* p =
 84
while(NULL != p)
 85
(p-&data).print();
 87
printf("--&");
 88
p = p-&
 89
printf("NULL");
 91
return RET_SUCCESS;
 92 }
 93 
 94 //获取头结点元素
 95 int getHead(ListNode* &head,ELEMTYPE& elem)
 96 {
 97
if(NULL == head)
 98
return RET_FAILURE;
100
elem = head-&
102
return RET_SUCCESS;
103 }
104 
105 //获取尾结点元素
106 int getTail(ListNode* &head,ELEMTYPE& elem)
107 {
108
if(NULL == head)
109
return RET_FAILURE;
111
ListNode* p =
113
while(NULL != p-&next)
114
p = p-&
116
elem = p-&
118
return RET_SUCCESS;
119 }
120 
121 //在相等元素后插入
122 int insertNode(ListNode* &head,ELEMTYPE& elem)
123 {
124
if(NULL == head)
125
return RET_FAILURE;
127
ListNode* p =
129
while(NULL != p)
130
if(p-&data == elem)
132
ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
134
pNode-&data =
135
pNode-&next = p-&
136
p-&next = pN
137
return RET_SUCCESS;
138
p = p-&
140
return RET_FAILURE;
142 }
143 
144 //删除相应元素
145 int deleteNode(ListNode* &head,ELEMTYPE& elem)
146 {
147
if(NULL == head)
148
return RET_FAILURE;
150
if(elem == head-&data)
152
return deleteHead(head,elem); 
154
ListNode* p =
156
ListNode* q =
157
while(NULL != p)
158
if(p-&data == elem)
160
q-&next = p-&
162
free(p);
163
return RET_SUCCESS;
164
q =
166
p = p-&
167
return RET_FAILURE;
169 }
170 
171 //在相应位置插入
172 int insertLocation(ListNode* &head,int iLocation,ELEMTYPE& elem)
173 {
174
if(NULL == head)
175
if(iLocation != 0)
177
return RET_FAILURE;
179
else
181
return insertAtHead(head,elem);
183
if(0 == iLocation)
186
return insertAtHead(head,elem);
188
int i = 0;
190
ListNode* p =
191
while(NULL != p)
192
if( i == iLocation - 1)
194
ListNode* pNode = (ListNode*)malloc(sizeof(ListNode));
196
pNode-&data =
197
pNode-&next = p-&
198
p-&next = pN
199
return RET_SUCCESS;
200
p = p-&
202
i++;
203
return RET_FAILURE;
205 }
206 
207 //删除相应位置元素
208 int deleteLocation(ListNode* &head,int iLocation,ELEMTYPE& elem)
209 {
210
if(NULL == head)
211
return RET_FAILURE;
213
if(0 == iLocation)
215
return deleteHead(head,elem);
217
int i = 0;
219
ListNode* p =
220
ListNode* q =
221
while(NULL != p)
222
if(i == iLocation)
224
elem = p-&
226
q-&next = p-&
227
free(p);
228
return RET_SUCCESS;
229
i++;
231
q =
232
p = p-&
233
return RET_FAILURE;
235 }

236 
237 //链表长度
238 int getListLength(ListNode* &head)
239 {
240
if(NULL == head)
241
return 0;
243
int i = 0;
245
ListNode* p =
246
while(NULL != p)
247
p= p-&
249
i++;
250
return
252 }
253 
254 //查找元素在链表中位置
255 int search(ListNode* &head,ELEMTYPE& elem,int &iLocation)
256 {
257
if(NULL == head)
258
return RET_FAILURE;
260
ListNode* p =
262
int i = 0;
263
while(NULL != p)
264
if(p-&data == elem)
266
iLocation =
268
return RET_SUCCESS;
269
i++;
271
p = p-&
272
return RET_FAILURE;
274 }
275 
276 //是否空
277 int isEmpty(ListNode* &head)
278 {
279
if(NULL == head)
280
return TRUE;
282
return FALSE;
284 }
285 
286 //清除所有结点
287 int clearAll(ListNode* &head)
288 {
289
ELEMTYPE
290
while(head != NULL)
291
deleteHead(head,elem);
293
return RET_SUCCESS;
295 }
296 
297 //逆序
298 int reverse(ListNode* &head)
299 {
300
if(NULL == head)
301
return RET_FAILURE;
303
if(NULL == head-&next)
305
return RET_SUCCESS;
307
ListNode* p =
309
ListNode* q = head-&
310
ListNode* pT
311
while(q != NULL)
312
pTemp = q-&
314
q-&next =
315
p =
316
q = pT
317
head-&next = NULL;
319
head =
320
return RET_SUCCESS;
321 }
322 
323 //排序
324 void sort(ListNode* &head)
325 {
326
if(NULL == head)
327
return;
329
}
330 
331
ListNode* p =
332
while(NULL != p)
333
ListNode* q =
335
while(NULL != q-&next)
336
if(q-&data & q-&next-&data)
338
ELEMTYPE tempElem = q-&
340
q-&data = q-&next-&
341
q-&next-&data = tempE
342
q = q-&
344
p = p-&
346
}
347 }

免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动