C++课件简单链表及其应用
合集下载
课件-链表用法-全

} return head ; }
建立链表过程
初始状态 读入1后
head NULL
head
tail NULL
temp NULL
tail temp
1 NULL
建立链表过程
读入2后 head
1
读入3后
hea d
1
tail tem p
2 NULL
tail
tem p
2
3
NULL
9.2.2 单向链表的操作
9.2.2 单向链表的操作
建立单向链表
声明一个链首指针变量head,并赋初值 NULL(包含0个节点的链表)
动态分配一个新节点,将该节点链入链尾 重复上一步
例子1:建立链表,读入n个整数,每 个整数作为一个新结点插入到链尾
#include <iostream.h> struct node {
ቤተ መጻሕፍቲ ባይዱ
例子3:编写一个函数,在例1的链表 中查找包含指定整数的节点
node * findData(int n, node * head) {
node *curNode = head; while ( curNode ) {
if ( curNode->data == n) { cout<<"Find "<<n<<" in the list."<<endl; return curNode;
原链头节点的前驱指针指向新节点 新节点的后继指针指向原链头节点 新链头节点的前驱指针置为空指针
例子6:编写一个函数,按数据输入 的顺序建立双向链表
node *createBidirList (int n) { node *temp, *tail = NULL, *head = NULL ; int num; cin >> num; head = new node ; // 为新节点动态分配内存 if (head == NULL){ cout << "No memory available!"; return NULL; } else { head->data = num; head->next = NULL; head->pre = NULL; tail = head; }
建立链表过程
初始状态 读入1后
head NULL
head
tail NULL
temp NULL
tail temp
1 NULL
建立链表过程
读入2后 head
1
读入3后
hea d
1
tail tem p
2 NULL
tail
tem p
2
3
NULL
9.2.2 单向链表的操作
9.2.2 单向链表的操作
建立单向链表
声明一个链首指针变量head,并赋初值 NULL(包含0个节点的链表)
动态分配一个新节点,将该节点链入链尾 重复上一步
例子1:建立链表,读入n个整数,每 个整数作为一个新结点插入到链尾
#include <iostream.h> struct node {
ቤተ መጻሕፍቲ ባይዱ
例子3:编写一个函数,在例1的链表 中查找包含指定整数的节点
node * findData(int n, node * head) {
node *curNode = head; while ( curNode ) {
if ( curNode->data == n) { cout<<"Find "<<n<<" in the list."<<endl; return curNode;
原链头节点的前驱指针指向新节点 新节点的后继指针指向原链头节点 新链头节点的前驱指针置为空指针
例子6:编写一个函数,按数据输入 的顺序建立双向链表
node *createBidirList (int n) { node *temp, *tail = NULL, *head = NULL ; int num; cin >> num; head = new node ; // 为新节点动态分配内存 if (head == NULL){ cout << "No memory available!"; return NULL; } else { head->data = num; head->next = NULL; head->pre = NULL; tail = head; }
C语言链表课件

return counter;
}//Count_LinkList
Void ChangeLinkList(LinkList &L) { LinkList p, q, s, r, t; q=null; r=L; t=null; //r指示原表的表尾,q是临时表 的表头指针,t指示临时表的表尾,p指示当前正在处理的结点 p=L→next; while(p) { if(p→data %2 == 1) { // p结点是奇数结点 s = p; r→next = p→next; //从原表中删除奇 数结点 s→data = s→data + 1; s→next = null; if(!q) { q = s; t = s ; } //在临时表中插入第一 个结点 else { t→next = s; t = s; } }//if else r = r→next; p = p→next; //处理下一个结点 }//while r→next=q; //将临时表链接到原表之后 }//ChangeLinkList
链表
结点(数据元素) = 元素(数据元素的映象) + 指针(指示后继元素存储位置) 结点 元素(data) 指针(next)
用一组地址任意的存储单元存放线性表中的数据元素。
链表:以“结点的序列”表示线性表
使用内存分配函数,动态申请和释放堆中的存储空间。
P124
struct node{//定义节点类型 int data; node * next; };
void main( ) { node * h; h=CreList( ); PrintList(h); }
node *CreList()
{node A_node; node *head; //首地址 node* s; //当前结点 head = NULL; printf("\n Please input the number ( 0 the end):\t"); scanf("%d",&A_node.data);
C程序设计2-第五讲-链表 PPT课件

2
main() {
struct BuJian xsq,yp,cpu,nc,jx; int ZongJiaGe; FILE * fp; fp = fopen("e:\\a.txt","r"); fscanf(fp,"%s %s %d",xsq.PinPai,xsq.XingHao,&xsq.JiaGe); fscanf(fp,"%s %s %d",yp.PinPai,yp.XingHao,&yp.JiaGe); fscanf(fp,"%s %s %d",cpu.PinPai,cpu.XingHao,&cpu.JiaGe); fscanf(fp,"%s %s %d",nc.PinPai,nc.XingHao,&nc.JiaGe); fscanf(fp,"%s %s %d",jx.PinPai,jx.XingHao,&jx.JiaGe); fclose(fp);
3
ZongJiaGe = xsq.JiaGe + yp.JiaGe + cpu.JiaGe + nc.JiaGe + jx.JiaGe ;
fp = fopen("e:\\b.txt","w");
fprint(fp,"%s %s %d\n",xsq.PinPai,xsq.XingHao,xsq.JiaGe); fprint(fp,"%s %s %d\n",yp.PinPai,yp.XingHao,yp.JiaGe); fprint(fp,"%s %s %d\n",cpu.PinPai,cpu.XingHao,cpu.JiaGe); fprint(fp,"%s %s %d\n",nc.PinPai,nc.XingHao,nc.JiaGe); fprint(fp,"%s %s %d\n",jx.PinPai,jx.XingHao,jx.JiaGe);
main() {
struct BuJian xsq,yp,cpu,nc,jx; int ZongJiaGe; FILE * fp; fp = fopen("e:\\a.txt","r"); fscanf(fp,"%s %s %d",xsq.PinPai,xsq.XingHao,&xsq.JiaGe); fscanf(fp,"%s %s %d",yp.PinPai,yp.XingHao,&yp.JiaGe); fscanf(fp,"%s %s %d",cpu.PinPai,cpu.XingHao,&cpu.JiaGe); fscanf(fp,"%s %s %d",nc.PinPai,nc.XingHao,&nc.JiaGe); fscanf(fp,"%s %s %d",jx.PinPai,jx.XingHao,&jx.JiaGe); fclose(fp);
3
ZongJiaGe = xsq.JiaGe + yp.JiaGe + cpu.JiaGe + nc.JiaGe + jx.JiaGe ;
fp = fopen("e:\\b.txt","w");
fprint(fp,"%s %s %d\n",xsq.PinPai,xsq.XingHao,xsq.JiaGe); fprint(fp,"%s %s %d\n",yp.PinPai,yp.XingHao,yp.JiaGe); fprint(fp,"%s %s %d\n",cpu.PinPai,cpu.XingHao,cpu.JiaGe); fprint(fp,"%s %s %d\n",nc.PinPai,nc.XingHao,nc.JiaGe); fprint(fp,"%s %s %d\n",jx.PinPai,jx.XingHao,jx.JiaGe);
计算机软件及应用链表cppt

int Mtime;
// 节目长度为分钟
ActList *next;
// 指向 ActList 结构的指针
};
ActList *head;
// 链头指针
ActList *Create() {
// 定义一个指向 AcitList 结构 //的指针函数,名为 Create
ActList *p=NULL; // 指针,指向个待插入的结点
head 节目1 头指针
节目2
下面的程序是建立链表的过程。
节目n
NULL
11.2 建立链表的过程
//************************************
//* 程 序 名:11_1.cpp
*
//* 作 者:wuwh
*
//* 编制时间:2002年11月26日
*
//* 主要功能:链表
ActList *q=NULL; // 指针,用于在其后插入结点
head = NULL;
// 一开始链表为空
int Time;
// 节目时长,如为0则退出
// 以下是给新结点输入节目信息
cout << "输入节目时长:";
cin >> Time;
while(Time != 0) // 当该节目的时长不为0时,将其
cout << "\n输入节目时长:";
cin >> Time;
// 输入下一个节目时长
} // 一旦跳出while循环,说明有一个节目时长为0
if (head != NULL)
q->next = NULL;
// 让q所指的最后一个结点的指针域为空说明这已是链尾了
《C语言链表》课件

了解如何删除链表中的指定节点
详细描述
删除链表中的节点需要找到要删除的节点,修改其前一个节点的指针,使其指向要删除节点的下一个 节点,然后将要删除节点的指针置为NULL。如果要删除的是头节点或尾节点,还需要对头指针或尾 指针进行相应的修改。
遍历链表
总结词
了解如何遍历链表中的所有节点
VS
详细描述
遍历链表需要从头节点开始,依次访问每 个节点,直到达到链表的尾部。在遍历过 程中,可以使用一个指针变量来指向当前 节点,每次循环将指针向后移动一个节点 ,即修改指针的next指针。
链表和循环链表的主要区别在于它们的最后一个节点指向的方向。在链表中,最后一个节点指向NULL; 而在循环链表中,最后一个节点指向第一个节点。循环链表具有更好的性能,但实现起来相对复杂一些 。
05
总结与展望
总结链表的重要性和应用场景
总结1
链表作为C语言中一种基本的数据结构,在计算机科学中 有着广泛的应用。通过学习链表,可以更好地理解数据 结构的基本概念,提高编程能力和解决实际问题的能力 。
详细描述
合并两个有序链表可以通过比较两个链表的 节点值来实现。从头节点开始比较,将较小 的节点添加到结果链表中,并将指针向后移 动。重复此过程直到其中一个链表为空。如 果还有剩余的节点,将其添加到结果链表的 末尾。这种方法的时间复杂度为O(n),其中
n为两个链表中节点的总数。
04
常见错误与注意事项
内存泄漏问题
内存泄漏定义
在C语言中,内存泄漏是指在使用动 态内存分配函数(如malloc、calloc 、realloc等)分配内存后,未能正确 释放这些内存,导致程序运行过程中 不断占用越来越多的内存,最终可能 导致程序崩溃或性能下降。
详细描述
删除链表中的节点需要找到要删除的节点,修改其前一个节点的指针,使其指向要删除节点的下一个 节点,然后将要删除节点的指针置为NULL。如果要删除的是头节点或尾节点,还需要对头指针或尾 指针进行相应的修改。
遍历链表
总结词
了解如何遍历链表中的所有节点
VS
详细描述
遍历链表需要从头节点开始,依次访问每 个节点,直到达到链表的尾部。在遍历过 程中,可以使用一个指针变量来指向当前 节点,每次循环将指针向后移动一个节点 ,即修改指针的next指针。
链表和循环链表的主要区别在于它们的最后一个节点指向的方向。在链表中,最后一个节点指向NULL; 而在循环链表中,最后一个节点指向第一个节点。循环链表具有更好的性能,但实现起来相对复杂一些 。
05
总结与展望
总结链表的重要性和应用场景
总结1
链表作为C语言中一种基本的数据结构,在计算机科学中 有着广泛的应用。通过学习链表,可以更好地理解数据 结构的基本概念,提高编程能力和解决实际问题的能力 。
详细描述
合并两个有序链表可以通过比较两个链表的 节点值来实现。从头节点开始比较,将较小 的节点添加到结果链表中,并将指针向后移 动。重复此过程直到其中一个链表为空。如 果还有剩余的节点,将其添加到结果链表的 末尾。这种方法的时间复杂度为O(n),其中
n为两个链表中节点的总数。
04
常见错误与注意事项
内存泄漏问题
内存泄漏定义
在C语言中,内存泄漏是指在使用动 态内存分配函数(如malloc、calloc 、realloc等)分配内存后,未能正确 释放这些内存,导致程序运行过程中 不断占用越来越多的内存,最终可能 导致程序崩溃或性能下降。
C语言链表(能看得懂的)93页PPT

11
11.7.3 处理动态链表所需的函数
C 语言使用系统函数动态开辟和释放存储单元 1.malloc 函数
函数原形:void *malloc(unsigned int size); 作用:在内存的动态存储区中分配 一个 长度为size 的连续空间。 返回值:是一个指向分配域起始地址的指针(基本 类型void)。 执行失败:返回NULL
else p2->next=p1->next;
例
printf("delete:%ld\n",num);
题
n=n-1; }
10
else printf("%ld not been found!\n",num);
end: return(head); }
没找到
32
11.7.7 对链表的插入操作
插入结点:将一个结点插入到已有的链表中 插入原则: 1、插入操作不应破坏原链接关系 2、插入的结点应该在它该在的位置 实现方法:
p2
89.5
90
(a)
p1
P2->next 指向p1 新开辟的结点。
head
99101
99103
p2
89.5
90
(b)
18
图11.14
p1
head
99101 89.5
99103 90
p2
(c)
P2指向新结 点p2=p1
19
head
99101 89.5
图11.15
p1
99101 89.5
99107 85
ANSI C 的三个函数(头文件 malloc.h) void *malloc(unsigned int size) void *calloc(unsigned n, unsigned size) void free(void *p)
C语言课件 链表
3.处理动态链表所需的函数
上例是比较简单的,所有结点都是在程序中定义 的,不是临时开辟的,也不能用完后释放,这种链表 称为“静态链表”。 前面讲过,链表结构是动态生地分配存储的,即 在需要时才开辟一个结点的存储单元 以便插入或追 加节点,删除节点后需要释放节点占用的内存单元。 C 语言提供了相应的函数。
⑴ void *malloc(unsigned int size) :在内存的动态存储区中分 配一个长度为size的连续空间。成功,则返回一个void型的空指针, 否则,返回NULL. 分配内存的字节数。
使用方法: ptr=malloc(size);
返回空类型的指针。 成功:返回内存的地址。 失败:返回NULL。 ⑵void free(ptr) 作用: 释放ptr指向的内存空间。 (3)void *calloc(unsigned n,unsigned size) 在内存的动态区 存储中分配n个长度为size的连续空间。函数返回分配域的起始 地址;如果分配不成功,返回0。
删除结点的函数: struct student *del (struct student *head,int num) {struct student *p1,*p2; if (head==NULL) {printf ("\nlist is null\n");} p1=head; while (p1->num!=num && p1->next!=NULL) {p2=p1;p1=p1->next;} if (p1->num==num) {if (p1==head) head=p1->next; else p2->next=p1->next; printf ("delete:%d\n",num); } else printf ("%ld not been found!",num); return(head); }
C语言_链表ppt课件
} 许多问题中,有时候为了操作方便,需要在第一个节点之前增加一个
特殊的节点,称为头节点,它的data字段不含信息或根据问题的需要 存放特殊信息。
2、链表的遍历(显示链表)
一个非递归算法
以下函数disp()用于显示头节点为*h的链表的所有节点 数据域。
void disp(struct Node *h) { struct Node *p=h; printf("输出链表:"); if(p==NULL) printf("空表\n"); else { while (p->next!=NULL) { printf("%4d",p->data); p=p->next; } printf("%4d\n",p->data); }
在链表结尾出插入一个元素
p
data
首先要用一个循环语句找到q
q
q=h;
h
...
NULL
while(q->next!=NULL)
q=q->next;
p
然后执行插入语句:
data
p->next=NULL;
q
q->next=p;
h
...
NULL
p
data
q
h
...
NULL
在链表中间插入一个元素
p
data
}
单链表的插入
.
3、链表的插入(头指针的情况下)
对于插入有以下几种情况 在一个空链表上插入一个元素。 (即要插入位置前方和后方均无元素) 从链表表头处插入一个元素 (即要插入的位置前方无元素,后方有元素) 从链表结尾处处插入一个元素 (即要插入的位置后方五元素,前方有元素) 从链表的中间插入 (即要插入的位置前方和后方均有元素) 其中第三种情况可以按照第四种情况处理,但有一定特殊性所以将 其分开 注意:产生新的节点必须用malloc或者calloc开辟空间
特殊的节点,称为头节点,它的data字段不含信息或根据问题的需要 存放特殊信息。
2、链表的遍历(显示链表)
一个非递归算法
以下函数disp()用于显示头节点为*h的链表的所有节点 数据域。
void disp(struct Node *h) { struct Node *p=h; printf("输出链表:"); if(p==NULL) printf("空表\n"); else { while (p->next!=NULL) { printf("%4d",p->data); p=p->next; } printf("%4d\n",p->data); }
在链表结尾出插入一个元素
p
data
首先要用一个循环语句找到q
q
q=h;
h
...
NULL
while(q->next!=NULL)
q=q->next;
p
然后执行插入语句:
data
p->next=NULL;
q
q->next=p;
h
...
NULL
p
data
q
h
...
NULL
在链表中间插入一个元素
p
data
}
单链表的插入
.
3、链表的插入(头指针的情况下)
对于插入有以下几种情况 在一个空链表上插入一个元素。 (即要插入位置前方和后方均无元素) 从链表表头处插入一个元素 (即要插入的位置前方无元素,后方有元素) 从链表结尾处处插入一个元素 (即要插入的位置后方五元素,前方有元素) 从链表的中间插入 (即要插入的位置前方和后方均有元素) 其中第三种情况可以按照第四种情况处理,但有一定特殊性所以将 其分开 注意:产生新的节点必须用malloc或者calloc开辟空间
C语言链表详解PPT课件
撤消原来的链接关系。 两种情况: 1、要删的结点是头指针所指的结点则直接操作; 2、不是头结点,要依次往下找。 另外要考虑:空表和找不到要删除的结点
26
链表中结点删除
需要由两个临时指针: P1: 判断指向的结点是不是要删除的结点 (用于寻找); P2: 始终指向P1的前面一个结点;
27
图 11.19
4
结点里的指针是存放下一个结点的地址
Head
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D Null
1、链表中的元素称为“结点”,每个结点包括两 个域:数据域和指针域;
2、单向链表通常由一个头指针(head),用于指 向链表头;
3、单向链表有一个尾结点,该结点的指针部分指
7
(4)删除操作是指,删除结点ki,使线性表的长度 减1,且ki-1、ki和ki+1之间的逻辑关系发生如下变 化:
删除前,ki是ki+1的前驱、ki-1的后继;删除后,ki-1 成为ki+1的前驱,ki+1成为ki-1的后继.
(5)打印输出
8
一个指针类型的成员既可指向其它类型的结构体数 据,也可以指向自己所在的结构体类型的数据
(x7,y7)
为了表示这种既有数据又有指针的情况, 引入结构这种数据类型。
3
11.7 用指针处理链表
链表是程序设计中一种重要的动态数据结构, 它是动态地进行存储分配的一种结构。
动态性体现为: 链表中的元素个数可以根据需要增加和减少,不 像数组,在声明之后就固定不变;
元素的位置可以变化,即可以从某个位置删除, 然后再插入到一个新的地方;
26
链表中结点删除
需要由两个临时指针: P1: 判断指向的结点是不是要删除的结点 (用于寻找); P2: 始终指向P1的前面一个结点;
27
图 11.19
4
结点里的指针是存放下一个结点的地址
Head
1249
1249
A 1356
1356
B 1475
1475
C 1021
1021
D Null
1、链表中的元素称为“结点”,每个结点包括两 个域:数据域和指针域;
2、单向链表通常由一个头指针(head),用于指 向链表头;
3、单向链表有一个尾结点,该结点的指针部分指
7
(4)删除操作是指,删除结点ki,使线性表的长度 减1,且ki-1、ki和ki+1之间的逻辑关系发生如下变 化:
删除前,ki是ki+1的前驱、ki-1的后继;删除后,ki-1 成为ki+1的前驱,ki+1成为ki-1的后继.
(5)打印输出
8
一个指针类型的成员既可指向其它类型的结构体数 据,也可以指向自己所在的结构体类型的数据
(x7,y7)
为了表示这种既有数据又有指针的情况, 引入结构这种数据类型。
3
11.7 用指针处理链表
链表是程序设计中一种重要的动态数据结构, 它是动态地进行存储分配的一种结构。
动态性体现为: 链表中的元素个数可以根据需要增加和减少,不 像数组,在声明之后就固定不变;
元素的位置可以变化,即可以从某个位置删除, 然后再插入到一个新的地方;
C++课件 简单链表及其应用
总结和参考资料
1 总结
链表是一种灵活的数据结构,可用于解决各种问题。理解链表的实现原理和应用场景对 于编程非常重要。
2 参考资料
1. 数据结构与算法分析 (C++语言描述) 2. 算法导论 (原书第三版)
尾节点
链表的最后一个节点被称为尾节点,它包含 数据并指向NULL。
删除节点
在单向链表中,删除节点需要修改前一个节 点的指针,使其指向下一个节点。
双向链表的实现原理
前向指针
每个节点除了后向指针,还有一个指向前一个节 点的前向指针。
后向指针
每个节点除了前向指针,还有一个指向后一个节 点的后向指针。
应用场景:LRU Cache的实现
1
LRU Cache
LRU Cache是一种常见的缓存算法,使用链表来存储数据。最近使用的数据位 于链表的头部,最久未使用的数据位于链表的尾部。
2
插入数据
当新的数据被访问时,可以将其插入到链表的头部。如果链表已满,则删除尾部 的节点。
3
பைடு நூலகம்
查询数据
当数据被访问时,可以将其从当前位置移动到链表的头部。
应用场景:判断链表是否存在环
1 快慢指针
2 时间复杂度
使用两个指针,一个快指针和一个慢指针, 从链表的头部开始遍历。如果链表存在环, 快指针会在某个时刻追上慢指针。
这种方法的时间复杂度是O(n),其中n是 链表的长度。
常见问题及解决方案
内存泄漏
确保在删除节点时释放相关内存。
链表长度限制
通过设置最大长度或使用动态扩展的数据结构 来解决。
C++课件 简单链表及其应 用
本课件将介绍链表的定义和基本操作,单向链表的实现原理,双向链表的实 现原理,以及链表在LRU Cache的实现和判断链表是否存在环的应用场景。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
cout <<temp->data<<endl;
temp=temp->next; }
}2021/3/4
12
1.什么是传统机械按键设计?
传统的机械按键设计是需要手动按压按键触动PCBA上的 开关按键来实现功能的一种设计方式。
传统机械按键结构层图:
按
PCBA
键
开关 键
传统机械按键设计要点: 1.合理的选择按键的类型, 尽量选择平头类的按键,以 防按键下陷。 2.开关按键和塑胶按键设计 间隙建议留0.05~0.1mm, 以防按键死键。 3.要考虑成型工艺,合理计 算累积公差,以防按键手感 不良。
输出各结点中的数据。
#define NULL 0
p=head;
struct student
do
{ long num;
{ cout<<p->num<<p->score;
float score;
p=p->next;
student *next;
}while(p!=NULL);}
};
void main()
{student a,b,c,*head,*p;
{ cout<<“要访问的结点数大于链表的结点数.”<<‘\n’;
return 0; }
temp=mp;
}
2021/3/4
14
. 统计链表结点的个数
int node_count(node* head) { node* temp=head;
int count=0; while(temp!=0) { count++;
2021/3/4
7
. 创建无序链表
一个链表是有若干个结点连接而成,创建 链表实际上是创建链表中的各个结点,并 将它们连接起来。
函数nosorted_create( )实现创建链表,其 算法为:如果链表为空(head==0),则将该 结点设置为表头;如果链表非空,则将该 结点加入到链表的末尾。
2021/3/4
简单链表及其应用
2021/3/4
1
链表是指将一组同类型数据(通常为结构体类
型)按其特有的方式连接在一起的一种数据结构。
链表中的元素称为结点。每一个结点都包含两 类数据:一类数据称为结点的值域,它是描述该
结点所包含的实际数据,可以由多个不同类型的
数据构成;另一类数据称为链域,它用来存储与
本结点相邻的结点的地址,其作用是将各个结点 连接在一起,它通常是与结点同类型的指针。
…… 200 …… 135 170 …… Null 130 110 …… 205 160 ……
5
用C++语言描述的一个简单 的单链表如下:
struct node{
int data;
//值域
node *next; //链域
};
2021/3/4
6
例. 建立一个简单的链表,它由3个学生数据的结点组成,
10
链表创建结束
…
头结点 结点n 新结点
data
…
next
data 0 next next
…
头结点 结点n
data
data
…
next
0
head
pEnd
(a) 结束前 pNew=new node;
pNew
2021/3/4
head
pEnd (b) 结束后 pEnd->next=0; delete pNew;
11
. 链表的输出
void ShowList(node* head)
{ if(head==0)
{ cout<<"List is empty!"<<endl;
return;
}
node *temp=head;
cout <<"now the items of list are: \n";
while(temp!=0){
a.num=99101; a.score=89.5;
b.num=99103; b.score=90;
c.num=99107; c.score=85;
head=&a;
/*将结点a的起始地址赋给头指针head*/
a.next=&b;
/*将结点b的起始地址赋给a结点的next成员*/
b.next=&c;
c.next=NULL;
NULL
2021/3/4
4
某单链表示意图如下:
head
bat
头指针 head 165
cat
eat
… mat ^
2021/3/4
…… 110 …… 130 135 …… 160 165 170 …… 200 205 ……
……… hat ……. cat eat …. mat bat fat
…… jat lat ……
…
头结点
结点n 结点n+1
data
…
next
data data next next
data
data data
…
next
next next
head
pEnd pNew (a) 加入前 pNew=new node;
2021/3/4
head
pEnd
pNew
(b) 加入后 pEnd->next=pNew; pEnd=pNew;
线性结头构结点 head a0 a1 a2
空指针
a3 a4
结点可以不连续存储 表可扩充
2021/3/4
3
单链表的存储映像
free (a) 可利用存储空间
a0 a2
a1 a3
head
free
(b) 经过一段运行后的单链表结构
head 2000
2000 A
2114
2114 B
2056
2056 C
8
将结点设置为表头的过程如下图所示:
head pEnd
pNew
head 头结点
pEnd pNew
(a) 加入结点前 head=0; pEnd=pNew;
2021/3/4
(b) 加入结点后 head=pNew; pEnd=pNew;
9
将结点加到链表末尾的过程如下图所示:
…
头结点 结点n 新结点
任何一个链表都一个起始指针,称为该链表的
头指针(head)。 链表的最后一个结点称为尾结点,它的链域指
针不指向任何结点,通常将它设置为空指针。
2021/3/4
2
单链表 (Singly Linked List)
特点
存储后继结点
存储每数个据元元素素(表项)由结点(No存d储e地)构址 成。
data link
. 链表某个结点的访问
node* access(node* head,int n)
{
if(head==0)
{ cout<<"List is empty!"<<endl;
return 0;}
node *temp;
temp=head;
for(int i=1;i<n;i++)
{ if(temp->next==0)
temp=temp->next; } return count; }