VC链表的建立
合集下载
相关主题
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
此时p2->next=0 循环结束
node Insert(node *head, node *p) { node *p1, *p2; ... ... 工作指针的位置 p1=p2=head; if(head->a>=p->a) 也已确定 while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... 25 ... ... next p2 p1 head 18 next 20 next 22 next 23 next 0
head 18 next 20 next 22 next
如果传给p的 节点数据是25，例如 算法中的条件 显然不成立 则应继续下面的算法
p
25 next
23 next 0
2. 新节点插入在链表末尾节点之后；
P2所指节点与新节点 数据逐个比较，若为真， 则继续循环
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ... 直接判断 next
2. 新节点插入在链表末尾节点之后；
分析可知 node Insert(node *head, node *p) 如果仅插在末尾，那么 { node *p1, *p2; 指针p1不起作用 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 返回 } next 0 p2 p1
node Insert(node *head, node *p) 设形参head获得 { 一个链表的地址 node *p1, *p2; ... ... p->next=head; head=p; return head ; } ... ... 设函数调用时形参p p 17 获得一个节点的地址
next
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
next
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
node Insert(node *head, node *p) { node *p1, *p2; 插在首部的关键算法 ... ... if(head->a>=p->a) { p->next=head; head=p; return(head); } ... ... 形参被释放， 17 新节点被插在链表首部
p1 p2
25 next
head
18 next
20 ห้องสมุดไป่ตู้ext
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
2. 新节点插入在链表末尾节点之后；
这两个语句的关系 与删除节点的算法相同 node Insert(node *head, node *p) p1=p2; 同步 { p2=p2->next; node *p1, *p2; p1、p2保持一个节点的距离 ... ...
p1=p2=head; if(head->a>=p->a) p2已经到达链表末尾 while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; 现在来分析插入算法 } p2=p2->next; p } ... ... 25 ... ... next p2 p1
next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... if(head->a>=p->a) p1=p2=head; { while(p2->next && p2->a<p->a) {p->next=head; head=p; p1=p2; return(head); p2=p2->next; }} ... ... ......
链表的建立与访问
链表的插入
对链表的访问————插入一个节点
插入一个新节点，应按以下步骤设计算法： 1. 插入在链表的第一个节点之前； 2. 插入在链表的末尾节点之后；
3. 插入在链表的某两个节点之间。
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
2. 新节点插入在链表末尾节点之后；
因此，在插入算法中 它必须再判断一次
node Insert(node *head, node *p) { 以确定新节点 node *p1, *p2; 插在哪个位置 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } 本例中，条件为真，因此 else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 } next 0 p2 p1 head 18 next 20 next 22 next 23 next 0
next
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
node Insert(node *head, node *p) { node *p1, *p2; 条件为真 ... ... 应执行复合语句 if(head->a>=p->a) { p->next=head; head=p; return(head); 节点数据是17， } 根据题意应插在 ... ... p 第一个节点之前 17
p 17 next 20 next 22 next 23 next 0
head
18 next
1. 新节点插入在链表的第一个节点之前； 在有序链表中插入：
node Insert(node *head, node *p) { 设形参head获得 node *p1, *p2; 一个链表的地址 ... ... if(head->data>=p->a) { 设函数调用 p->next=head; head=p; return head ; 时形参p获得 } 一个节点的 p ... ... 17 地址
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
循环中有两个条件 本例结束循环的条件是 next=0
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) 但在下面的插入算法中 while(p2->next && p2->a<p->a) { 它并不知道是哪个条件结束 { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... 25 ... ... next p2 p1 head 18 next 20 next 22 next 23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { 显然，这是插入链表末尾的 node *p1, *p2; 条件及算法语句 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 返回 } next 0 p2 p1 head 18 next 20 next 22 next 23 next 0
p1 p2
若不为0，则继续循环
18 next 20 next 22 next 23 next 0
25 next
head
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前； node Insert(node *head, node *p) { node *p1, *p2; ... ... p->next=head; head=p; return(head); }
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
此时p2->next=0 循环结束
node Insert(node *head, node *p) { node *p1, *p2; ... ... 工作指针的位置 p1=p2=head; if(head->a>=p->a) 也已确定 while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... 25 ... ... next p2 p1 head 18 next 20 next 22 next 23 next 0
head 18 next 20 next 22 next
如果传给p的 节点数据是25，例如 算法中的条件 显然不成立 则应继续下面的算法
p
25 next
23 next 0
2. 新节点插入在链表末尾节点之后；
P2所指节点与新节点 数据逐个比较，若为真， 则继续循环
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ... 直接判断 next
2. 新节点插入在链表末尾节点之后；
分析可知 node Insert(node *head, node *p) 如果仅插在末尾，那么 { node *p1, *p2; 指针p1不起作用 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 返回 } next 0 p2 p1
node Insert(node *head, node *p) 设形参head获得 { 一个链表的地址 node *p1, *p2; ... ... p->next=head; head=p; return head ; } ... ... 设函数调用时形参p p 17 获得一个节点的地址
next
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
next
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
node Insert(node *head, node *p) { node *p1, *p2; 插在首部的关键算法 ... ... if(head->a>=p->a) { p->next=head; head=p; return(head); } ... ... 形参被释放， 17 新节点被插在链表首部
p1 p2
25 next
head
18 next
20 ห้องสมุดไป่ตู้ext
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
2. 新节点插入在链表末尾节点之后；
这两个语句的关系 与删除节点的算法相同 node Insert(node *head, node *p) p1=p2; 同步 { p2=p2->next; node *p1, *p2; p1、p2保持一个节点的距离 ... ...
p1=p2=head; if(head->a>=p->a) p2已经到达链表末尾 while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; 现在来分析插入算法 } p2=p2->next; p } ... ... 25 ... ... next p2 p1
next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... if(head->a>=p->a) p1=p2=head; { while(p2->next && p2->a<p->a) {p->next=head; head=p; p1=p2; return(head); p2=p2->next; }} ... ... ......
链表的建立与访问
链表的插入
对链表的访问————插入一个节点
插入一个新节点，应按以下步骤设计算法： 1. 插入在链表的第一个节点之前； 2. 插入在链表的末尾节点之后；
3. 插入在链表的某两个节点之间。
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
2. 新节点插入在链表末尾节点之后；
因此，在插入算法中 它必须再判断一次
node Insert(node *head, node *p) { 以确定新节点 node *p1, *p2; 插在哪个位置 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } 本例中，条件为真，因此 else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 } next 0 p2 p1 head 18 next 20 next 22 next 23 next 0
next
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前；
node Insert(node *head, node *p) { node *p1, *p2; 条件为真 ... ... 应执行复合语句 if(head->a>=p->a) { p->next=head; head=p; return(head); 节点数据是17， } 根据题意应插在 ... ... p 第一个节点之前 17
p 17 next 20 next 22 next 23 next 0
head
18 next
1. 新节点插入在链表的第一个节点之前； 在有序链表中插入：
node Insert(node *head, node *p) { 设形参head获得 node *p1, *p2; 一个链表的地址 ... ... if(head->data>=p->a) { 设函数调用 p->next=head; head=p; return head ; 时形参p获得 } 一个节点的 p ... ... 17 地址
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
循环中有两个条件 本例结束循环的条件是 next=0
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) 但在下面的插入算法中 while(p2->next && p2->a<p->a) { 它并不知道是哪个条件结束 { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... 25 ... ... next p2 p1 head 18 next 20 next 22 next 23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { 显然，这是插入链表末尾的 node *p1, *p2; 条件及算法语句 ... ... if(p2->a<p->a) if(head->a>=p->a) { { p2->next=p; p->next=0; } else p->next=head; head=p; return(head); } { p->next=p2; p1->next=p; } p return(head); ... ... 25 返回 } next 0 p2 p1 head 18 next 20 next 22 next 23 next 0
p1 p2
若不为0，则继续循环
18 next 20 next 22 next 23 next 0
25 next
head
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...
head
18 next
20 next
22 next
23 next 0
1. 新节点插入在链表的第一个节点之前； node Insert(node *head, node *p) { node *p1, *p2; ... ... p->next=head; head=p; return(head); }
p1 p2
25 next
head
18 next
20 next
22 next
23 next 0
2. 新节点插入在链表末尾节点之后；
node Insert(node *head, node *p) { node *p1, *p2; ... ... p1=p2=head; if(head->a>=p->a) while(p2->next && p2->a<p->a) { { p->next=head; head=p; return(head); p1=p2; } p2=p2->next; p } ... ... ... ...