1、为什么要使用链式存储结构?
因为我们前面讲的线性表的顺序存储结构,他是有缺点的。最大的缺点就是插入和删除时需要移动大量元素,这显然就需要耗费时间。要解决这个问题,我们就需要分析一下为什么当插入和删除时,就要移动大量元素,因为相邻两元素的存储位置也具有相邻关系,它们在内存中的位置也是挨着的,中间没有空隙,当然就无法快速介入,而删除之后。当中就会留出空隙,自然就需要弥补。问题就出在这里。
为了解决这个问题,自然而然的就出现了链式存储结构。
2、线性表链式存储结构的特点:
线性表的链式存储结构不考虑元素的存储位置,而是用一组任意的存储单元存储线性表的数据元素,这组存储单元可以是连续的,也可以是不连续的,这就意味着,这些数据元素可以存在内存未被占用的任意位置。
顺序存储结构:只需要存储数据元素信息。
链式存储结构:除了要存储数据元素信息之外,还要存储一个指示其直接后继元素的存储地址。
3、关键词:
数据域:存储数据元素信息的域。
指针域:存储直接后继位置的域。
指针或链:指针域中存储的信息。
结点(Node):指针域+数据域组成数据元素的存储映像。
头指针:链表中第一个结点的存储位置。
头节点:在单链表的第一个结点前附设一个结点,成为头结点。头结点的数据域不可以存储任何信息,可以存储线性表的长度等附加信息,头结点的指针域存储指向第一个结点的指针。
4、单链表:
定义:n个结点链成一个链表,即为线性表的链式存储结构,因此此链表的每个结点中只包含一个指针域,所以叫做单链表。
PS:线性链表的最后一个结点指针为“空”,通常用NILL或“^”符号表示。
头节点:在单链表的第一个结点前附设一个结点,成为头结点。头结点的数据域不可以存储任何信息,可以存储线性表的长度等附加信息,头结点的指针域存储指向第一个结点的指针。
5、头结点与头指针的异同
(1)头结点
- 头结点是为了操作的统一和方便而设立的,放在第一个元素的结点之前,其数据域一般无意义(也可存放链表的长度)
- 有了头结点,对第一元素结点前插入和删除第一结点,其操作就统一了
- 头结点不一定是链表的必要素
(2)头指针
- 头指针式指向第一个结点的指针,若链表有头结点,则是指向头结点的指针。
- 头指针具有标识作用,所以常用头指针冠以链表的名字。
- 无论链表是否为空,头指针均不为空。头指针是了链表的必要元素。
6、线性表链式存储结构代码描述
若线性表尾空表,则头结点的指针域为“空”
没有头结点的单链表:
带有头结点的单链表:
线性表的单链表存储结构:
1 typedefstructNode{ 2 3 ElemTypedata; 4 structNode*next; 5 }Node;
7、单链表的读取「GetElem」
算法思路:
- 声明一个结点p指向链表的第一个结点,初始化j从1开始;
- 当 j<i 时,就遍历链表,让p指针向后移动,不断指向下一结点,j 累加1;
- 若到链表末尾p为空,则说明第i个元素不存在;
- 否则查找成功,返回结点p的数据。
实现代码:
1 /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */ 2 /* 操作结果:用e返回L中第i个数据元素的值 */ 3 Status GetElem(LinkList L, int i, ElemType *e){ 4 5 int j = 1; 6 LinkList p = L->next; /* 声明一结点p,并让p指向L的第一个结点 */ 7 8 while (p && j < i) { /* p不为空并且计数器j还没有等于i时,循环继续 */ 9 p = p->next; /* 让p指向下一个结点 */ 10 ++ j; 11 } 12 13 if (!p || j > i) { 14 return Error; /* 第i个元素不存在 */ 15 } 16 17 *e = p->data; /* 取第i个元素的数据 */ 18 return OK; 19 }
算法复杂度分析:
算法复杂度取决于 i 的位置,当 i = 1 时,则不需要遍历,第一个就取出数据了,而当 i = n 时则遍历 n - 1 次才可以。因此最坏情况的 时间复杂度是O(n)。
注:链式存储的优势不在查找元素,在于插入和删除元素。
8、单链表的插入
单链表第 i 个数据插入结点的算法思路:
1、声明一个结点 p 指向链表第一个结点,初始化 j 从 1 开始;
2、当 j < i 时,就遍历链表,让 p 的指针向后移动,不断指向下一个结点,j 累加1;
3、若找到链表末尾 p 为空,则说明第 i 个元素不存在;
4、否则查找成功,在系统中生成一个空结点s;
5、将数据元素 e 赋值给 s -> data ;
6、单链表的插入标准语句 s->next = p -> next , p -> next = s ;
7、返回成功。
代码实现:
1 /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L), */ 2 /* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */ 3 Status ListInsert(LinkList *L, int i, ElemType e){ 4 5 int j = 1; 6 LinkList p = *L,s; 7 while (p && j<i) { /* 寻找第i个结点,也就是说当循环结束的时候,已经找到了要插入位置的前一个位置*/ 8 p = p->next; 9 ++ j; 10 } 11 if(!p || j > i){ /* 第i个元素不存在 */ 12 return Error; 13 } 14 s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */ 15 s->data = e; 16 s->next = p->next; /* 将p的后继结点赋值给s的后继 */ 17 p->next = s; /* 将s赋值给p的后继 */ 18 return OK; 19 }
malloc函数的作用就是生成一个新的结点,其类型与Node是一样的,其实质就是在内存中找到了一小块空地用来存放e数据s结点。
9、单链表的删除
算法思路:
1、生命一个结点p指向链表的第一个结点,初始化 j 从 1 开始;
2、当 j < i 时,就遍历链表,让p的指针向后移动,不断指向下一个结点,j 累加 1;
3、若遍历到链表的末尾p为空,则说明第i个元素不存在;
4、否则查找成功将欲删除的结点 p -> next 赋值给 q ;
5、单链表的删除标准语句:p -> next = q -> next ;
6、将 q 中结点中的数据赋值给e,作为返回;
7、释放 q 结点;
8、返回成功。
实现代码:
1 Status ListDelete(LinkList *L, int i, ElemType *e){ 2 3 int j = 1; 4 LinkList p,q; 5 p = *L; 6 while (p->next && j < i) { 7 p = p->next; 8 ++ j; 9 } 10 if(!(p->next) || j > i){ 11 return Error; 12 } 13 14 q = p->next; 15 p->next = q->next; 16 *e = q->data; 17 free(q); 18 return OK; 19 } 20 注:free函数的作用是让系统回收一个Node结点,释放内存。
10、单链表的整表创建
创建单链表的过程就是一个动态生成链表的过程。即从“空表”的初始态起,依次创建各元素结点,并逐个插入链表。
- 头插法
单链表整表创建的算法思路:
1、生命一个结点p和计数器i;
2、初始化一空链表L;
3、让L的头结点的指针指向NULL,即建立一个带头结点的单链表;
4、循环:
(1)生成一个新结点赋值给p;
(2)随机生成一数字赋值给p的数据域p->data ;
(3)将p插入到头结点与前一结点之间。
代码实现:
1 /* 随机产生n个元素的值,建立带表头结点的单链线性表L(头插法) */ 2 Status CreateListHead(LinkList *L,int n){ 3 LinkList p; 4 int i; 5 srand(time(0)); /* 初始化随机数种子 */ 6 *L = (LinkList)malloc(sizeof(Node)); 7 (*L)->next = NULL; /* 先建立一个带头结点的单链表 */ 8 for(i = 0; i < n; i ++){ 9 p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */ 10 p->data = rand()%100+1; /* 随机生成100以内的数字 */ 11 p->next = (*L)->next; 12 (*L)->next = p; /* 插入到表头 */ 13 } 14 return OK; 15 }
- 尾插法
实现代码:
1 /* 随机产生n个元素的值,建立带表头结点的单链线性表L(尾插法) */ 2 void CreateListTail(LinkList *L, int n) 3 { 4 LinkList p,r; 5 int i; 6 srand(time(0)); /* 初始化随机数种子 */ 7 *L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */ 8 r=*L; /* r为指向尾部的结点 */ 9 for (i=0; i<n; i++) 10 { 11 p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */ 12 p->data = rand()%100+1; /* 随机生成100以内的数字 */ 13 r->next=p; /* 将表尾终端结点的指针指向新结点 */ 14 r = p; /* 将当前的新结点定义为表尾终端结点 */ 15 } 16 r->next = NULL; /* 表示当前链表结束 */ 17 }
11、单链表的整表删除
算法思路:
1、声明一个结点p和q;
2、将第一个结点赋给p;
3、循环:
(1)将下一结点赋给q;
(2)释放p;
(3)将q赋值给p;
代码实现:
1 /* 随机产生n个元素的值,建立带表头结点的单链线性表L(头插法) */ 2 Status CreateListHead(LinkList *L,int n){ 3 LinkList p; 4 int i; 5 srand(time(0)); /* 初始化随机数种子 */ 6 *L = (LinkList)malloc(sizeof(Node)); 7 (*L)->next = NULL; /* 先建立一个带头结点的单链表 */ 8 for(i = 0; i < n; i ++){ 9 p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */ 10 p->data = rand()%100+1; /* 随机生成100以内的数字 */ 11 p->next = (*L)->next; 12 (*L)->next = p; /* 插入到表头 */ 13 } 14 return OK; 15 }
12、单链表结构与顺序存储结构优缺点
(1)存储分配方式
- 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素
- 单链表采用链式存储结构,用一组任意的存储单元依次存放线性表的元素
(2)时间性能
- 查找
- 顺序存储结构O(1)
- 单链表O(n)
- 插入和删除
- 顺序存储结构需要平均移动表长一半的元素,时间为O(n)
- 单链表在找出某位置的指针后,插入和删除时间仅为O(1)
- 空间性能
- 顺序存储结构需要预分配存储空间,分大了,浪费,分小了容易溢出。
- 单链表不需要分配存储空间,只要有就可以分配,元素个数也不受限制。
总结:
- 若线性表需要频繁查找,很少进行插入和删除操作时,宜采用顺序存储结构。若插入和删除频繁时,宜采用单链表结构。
- 当线性表的元素个数变化较大或者根本不知道有多大时,最好用单链表结构,这样不用考虑存储空间的大小问题。而如果事先知道了线性表的长度时,则使用顺序结构效率会比价高。
测试源码
1 // 2 // main.cpp 3 // 线性表的链式存储结构--单链表 4 // 5 // Created by Mr.G on 2018/10/17. 6 // Copyright © 2018年 Mr.G. All rights reserved. 7 // 8 9 #include "stdio.h" 10 #include "stdlib.h" 11 #include "string.h" 12 #include "ctype.h" 13 14 #include "math.h" 15 #include "time.h" 16 17 #define OK 1 18 #define Error 0 19 #define TRUE 1 20 #define FALSE 0 21 22 #define MAXSIZE 23 24 typedef int Status; 25 typedef int ElemType; 26 typedef struct Node{ 27 28 ElemType data; 29 struct Node *next; 30 }Node; 31 typedef struct Node *LinkList; /* 定义LinkList */ 32 33 Status visit(ElemType c){ 34 printf("%d\t",c); 35 return OK; 36 } 37 38 /* 初始化顺序线性表 */ 39 Status InitList(LinkList *L){ 40 41 *L = (LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点*/ 42 if(!(*L)){ /* 存储分配失败*/ 43 return Error; 44 } 45 (*L)->next = NULL; /* 指针域为空*/ 46 47 return OK; 48 } 49 50 int ListLength(LinkList L){ 51 int i = 0; 52 LinkList p = L->next; 53 while (p) { 54 i++; 55 p = p->next; 56 } 57 return i; 58 } 59 60 /* 初始条件:顺序线性表L已存在 */ 61 /* 操作结果:依次对L的每个数据元素输出 */ 62 Status ListTraverse(LinkList L){ 63 LinkList p = L->next; 64 while (p) { 65 visit(p->data); 66 p = p->next; 67 } 68 printf("\n"); 69 return OK; 70 } 71 72 /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L), */ 73 /* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */ 74 Status ListInsert(LinkList *L, int i, ElemType e){ 75 76 int j = 1; 77 LinkList p = *L,s; 78 while (p && j<i) { /* 寻找第i个结点,也就是说当循环结束的时候,已经找到了要插入位置的前一个位置*/ 79 p = p->next; 80 ++ j; 81 } 82 if(!p || j > i){ /* 第i个元素不存在 */ 83 return Error; 84 } 85 s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */ 86 s->data = e; 87 s->next = p->next; /* 将p的后继结点赋值给s的后继 */ 88 p->next = s; /* 将s赋值给p的后继 */ 89 return OK; 90 } 91 92 /* 初始条件:顺序线性表L已存在。操作结果:若L为空表,则返回TRUE,否则返回FALSE */ 93 Status ListEmpty(LinkList L){ 94 95 if(L->next) 96 return FALSE; 97 else 98 return TRUE; 99 } 100 101 /* 初始条件:顺序线性表L已存在。操作结果:将L重置为空表 */ 102 Status ClearList(LinkList *L){ 103 104 LinkList p,q; 105 p = (*L)->next; /* p指向第一个结点 */ 106 while (p) { 107 q = p->next; 108 free(p); 109 p = q; 110 } 111 (*L)->next = NULL; 112 return OK; 113 } 114 115 /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */ 116 /* 操作结果:用e返回L中第i个数据元素的值 */ 117 Status GetElem(LinkList L, int i, ElemType *e){ 118 119 int j = 1; 120 LinkList p = L->next; /* 声明一结点p,并让p指向L的第一个结点 */ 121 122 while (p && j < i) { /* p不为空并且计数器j还没有等于i时,循环继续 */ 123 p = p->next; /* 让p指向下一个结点 */ 124 ++ j; 125 } 126 127 if (!p || j > i) { 128 return Error; /* 第i个元素不存在 */ 129 } 130 131 *e = p->data; /* 取第i个元素的数据 */ 132 return OK; 133 } 134 135 int LocateElem(LinkList L,ElemType e){ 136 int i = 0; 137 LinkList p = L->next; 138 while (p) { 139 i ++; 140 if(p->data == e){ 141 return i; 142 } 143 p = p->next; 144 } 145 146 return 0; 147 } 148 149 Status ListDelete(LinkList *L, int i, ElemType *e){ 150 151 int j = 1; 152 LinkList p,q; 153 p = *L; 154 while (p->next && j < i) { 155 p = p->next; 156 ++ j; 157 } 158 if(!(p->next) || j > i){ 159 return Error; 160 } 161 162 q = p->next; 163 p->next = q->next; 164 *e = q->data; 165 free(q); return OK; 166 } 167 168 /* 随机产生n个元素的值,建立带表头结点的单链线性表L(头插法) */ 169 Status CreateListHead(LinkList *L,int n){ 170 LinkList p; 171 int i; 172 srand(time(0)); /* 初始化随机数种子 */ 173 *L = (LinkList)malloc(sizeof(Node)); 174 (*L)->next = NULL; /* 先建立一个带头结点的单链表 */ 175 for(i = 0; i < n; i ++){ 176 p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */ 177 p->data = rand()%100+1; /* 随机生成100以内的数字 */ 178 p->next = (*L)->next; 179 (*L)->next = p; /* 插入到表头 */ 180 } 181 return OK; 182 } 183 184 /* 随机产生n个元素的值,建立带表头结点的单链线性表L(尾插法) */ 185 void CreateListTail(LinkList *L, int n) 186 { 187 LinkList p,r; 188 int i; 189 srand(time(0)); /* 初始化随机数种子 */ 190 *L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */ 191 r=*L; /* r为指向尾部的结点 */ 192 for (i=0; i<n; i++) 193 { 194 p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */ 195 p->data = rand()%100+1; /* 随机生成100以内的数字 */ 196 r->next=p; /* 将表尾终端结点的指针指向新结点 */ 197 r = p; /* 将当前的新结点定义为表尾终端结点 */ 198 } 199 r->next = NULL; /* 表示当前链表结束 */ 200 } 201 202 int main() { 203 204 LinkList L; 205 ElemType e; 206 Status i; 207 int j,k; 208 i = InitList(&L); 209 printf("初始化L后:ListLength(L)=%d\n",ListLength(L)); 210 for(int j = 1; j <=5; j ++){ 211 i = ListInsert(&L, 1, j); 212 } 213 printf("在L的表头依次插入1~5后:L.data="); 214 ListTraverse(L); 215 216 printf("ListLength(L)=%d \n",ListLength(L)); 217 i = ListEmpty(L); 218 printf("L是否空:i=%d(1:是 0:否)\n",i); 219 220 i = ClearList(&L); 221 printf("清空L后:ListLength(L)=%d\n",ListLength(L)); 222 i = ListEmpty(L); 223 printf("L是否空:i=%d(1:是 0:否)\n",i); 224 225 for (int j = 1; j <= 10; j ++) { 226 ListInsert(&L, j, j); 227 } 228 printf("在L的表尾依次插入1~10后:L.data="); 229 ListTraverse(L); 230 printf("ListLength(L)=%d \n",ListLength(L)); 231 232 ListInsert(&L,1,0); 233 printf("在L的表头插入0后:L.data="); 234 ListTraverse(L); 235 printf("ListLength(L)=%d \n",ListLength(L)); 236 237 GetElem(L,5,&e); 238 printf("第5个元素的值为:%d\n",e); 239 240 for(int j = 3; j <= 4; j ++){ 241 k = LocateElem(L, j); 242 if(k) 243 printf("第%d个元素的值为%d\n",k,j); 244 else 245 printf("没有值为%d的元素\n",j); 246 } 247 248 k=ListLength(L); /* k为表长 */ 249 for (j = k + 1; j >= k; j --) { 250 i = ListDelete(&L, j, &e); 251 if(i == Error){ 252 printf("删除第%d个数据失败\n",j); 253 }else{ 254 printf("删除第%d个的元素值为:%d\n",j,e); 255 } 256 } 257 printf("依次输出L的元素:"); 258 ListTraverse(L); 259 260 j=5; 261 ListDelete(&L,j,&e); /* 删除第5个数据 */ 262 printf("删除第%d个的元素值为:%d\n",j,e); 263 264 printf("依次输出L的元素:"); 265 ListTraverse(L); 266 267 i=ClearList(&L); 268 printf("\n清空L后:ListLength(L)=%d\n",ListLength(L)); 269 CreateListHead(&L,20); 270 printf("整体创建L的元素(头插法):"); 271 ListTraverse(L); 272 273 i=ClearList(&L); 274 printf("\n删除L后:ListLength(L)=%d\n",ListLength(L)); 275 CreateListTail(&L,20); 276 printf("整体创建L的元素(尾插法):"); 277 ListTraverse(L); 278 279 return 0; 280 }
小V