链表操作的二级指针问题（C++版）

最新推荐文章于 2023-04-15 17:20:08 发布
最新推荐文章于 2023-04-15 17:20:08 发布
阅读量1.4k 收藏 38
点赞数 16
文章标签： 单链表 指针 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42295110/article/details/117634865
版权

本篇要解决的问题

        链表的所有相关操作中，什么操作用二级指针 ? 什么操作用一级指针?以及为什么这个操作要用一级指针?为什么那个操作要用二级指针？

背景

        我发现无论是观看学习视频，还是看数据结构相关的书籍，侧重点都是链表操作要如何移动相关结点。一些细小的地方，比如实现链表操作的伪代码函数的形参中，有的传一级指针，有的传二级指针。对于我等学渣。简直是无法理解。关键是有的同样的链表操作，有的视频用了一级指针，有的视频用了二级指针。很让人费解。而且网上与此相关的文章也只是给出了什么链表操作用什么指针，而没有给出为什么这样用？ 本篇文章不仅让你知道链表的什么操作用一级指针，什么操作用二级指针，以及为什么要这么用。

结论

链表的所有操作中，头插法建表、尾插法建表、链表的初始化操作、链表的销毁操作我们需要使用二级指针。而链表的插入、删除、查询、判空、打印操作使用一级指针即可实现。

链表的插入、删除、查询、判空、打印操作使用一级指针可以实现，使用二级指针亦可以实现，但是没必要。后面会画图说明为什么二级指针也可以实现。

验证

基础代码：

#include <stdio.h>
#include <stdlib.h>

#define ElemType int
#define null NULL
//定义单链表链表节点
typedef struct LNode {
  ElemType data;
  struct LNode *next;
}LNode;

//打印链表 
void printList(LNode *list){
	if(list == null){
		printf("链表头结点都没了,你还想打印啥?\n");
		return;
	}
	LNode *s = list->next;
	while(s!=null){
		printf("%d\n",s->data);
		s=s->next;
	}
}

链表头插代码：T(n)=O(n)   需要使用二级指针

//头插法建表  
bool createListHead(LNode **list,ElemType content[],int len){
	*list = (LNode *)malloc(sizeof(LNode));
	(*list)->next = null;
	for(int i = 0;i<len;i++){    
		LNode *s =(LNode *) malloc(sizeof(LNode));
		s->data = content[i];
		s->next = (*list)->next;
		(*list)->next = s; 
	}
	return true;
}

假如链表头插使用一级指针，错误代码如下：

//头插法建表  
bool createListHead(LNode *list,ElemType content[],int len){
	list = (LNode *)malloc(sizeof(LNode));
	list->next = null;
	for(int i = 0;i<len;i++){    
		LNode *s =(LNode *) malloc(sizeof(LNode));
		s->data = content[i];
		s->next = list->next;
		list->next = s; 
	}
	return true;
}

链表尾插代码:  T(bn)=O(n)    需要使用二级指针

//尾插法建表  T(n) = O(n)
bool createListTail(LNode **list,ElemType content[],int len){
	*list =(LNode *)malloc(sizeof(LNode));
	LNode *r;
	r=*list;
	for(int i = 0;i<len;i++){
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = content[i];
		r->next = s; 
		r=r->next;
	}
	r->next=null;
	return true;
}

假如链表尾插使用一级指针，错误代码如下:

//尾插法建表  T(n) = O(n)
bool createListTail(LNode *list,ElemType content[],int len){
	list =(LNode *)malloc(sizeof(LNode));
	LNode *r;
	r=list;
	for(int i = 0;i<len;i++){
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = content[i];
		r->next = s; 
		r=r->next;
	}
	r->next=null;
	return true;
}

测试方法代码：

int main(int argc, char *argv[])
{
	int a[]={1,2,3,4,5,6,7,8,9,10};
	//数组长度 
	int len =sizeof(a)/sizeof(a[0]);
	LNode *head=null;
	createListHead(&head,a,len);
	//createListTail(&head,a,len);
	printList(head);
    return 0;
}

测试结果：

使用二级指针的测试结果：

使用一级指针的测试结果：

分析原因：

此处以头插建立单链表代码进行分析，尾插法原因一样。

链表的初始化代码： T(n)=O(1)   需要使用二级指针

//单链表的初始化操作
bool initList(LNode **list){
	(*list) = (LNode *)malloc(sizeof(LNode));
	if((*list)==null){   //内存空间不足
		return false;
	}
	(*list)->next=null;
	return true;
}

假如链表初始化使用一级指针，错误代码如下:

//单链表的初始化操作 
bool initList(LNode *list){
	list = (LNode *)malloc(sizeof(LNode));
	if(list==null){   //内存空间不足
		return false;
	}
	list->next=null;
	return true;
}

测试方法代码：

int main(int argc, char *argv[])
{
	int a[]={1,2,3,4,5,6,7,8,9,10};
	//数组长度 
	int len =sizeof(a)/sizeof(a[0]);
	LNode *head=null;
    initList(&head);
    printList(head);
    return 0;
}

测试结果：

使用二级指针的测试结果：

使用一级指针的测试结果：

分析原因：

链表的销毁代码： T(n) = O(n)   需要使用二级指针

//链表的销毁代码
void destoryList(LNode **head){
	if((*head) == null){
		printf("该链表已经销毁,请勿重复销毁\n");
		return; 
	}
	while((*head)->next!=null){
		LNode *p = (*head)->next;
		(*head)->next = p->next;
		free(p);
	}
	free(*head);
	*head = null;
}

假如链表销毁使用一级指针，错误代码如下:

//链表的销毁代码
void destoryList(LNode *head){
	if(head == null){
		printf("该链表已经销毁,请勿重复销毁\n");
		return; 
	}
	while(head->next!=null){
		LNode *p = head->next;
		head->next = p->next;
		free(p);
	}
	free(head);
	head = null;
}

测试方法代码：

int main(int argc, char *argv[])
{
	int a[]={1,2,3,4,5,6,7,8,9,10};
	//数组长度 
	int len =sizeof(a)/sizeof(a[0]);
	LNode *head=null;
	createListHead(&head,a,len);
	printf("销毁链表前:\n");
	printList(head);
	destoryList(&head);
	printf("销毁链表后:\n");
	printList(head);
	return 0;
}

测试结果:

使用二级指针测试结果：

使用一级指针测试结果：

分析原因：

链表的销毁使用二级指针,不是因为一级指针不能把头结点和链表数据结点销毁掉，而是一级指针销毁掉数据结点和头结点之后，并不能对原来的头指针置为null,会导致原来的头指针成为野指针。

链表中能用一级指针实现的操作均能用二级指针实现，但是没必要。比如链表的判空操作。

链表判空代码： T(n)=O(1)     使用一级指针即可

//单链表的判空操作 T(n)=O(1)
bool isEmpty(LNode *list){          
	return list->next == null ? true:false; 
}

假如链表的判空代码使用二级指针,代码如下。 也能实现功能，但是没必要。

//单链表的判空操作 T(n)=O(1)
bool isEmpty(LNode **list){          
	return (*list)->next == null ? true:false; 
}

测试方法代码:

int main(int argc, char *argv[])
{
	int a[]={1,2,3,4,5,6,7,8,9,10};
	//数组长度 
	int len =sizeof(a)/sizeof(a[0]);
	LNode *head=null;
	createListHead(&head,a,len); //头插法建立单链表
	//printList(head); 
 	printf("头插法建立单链表后,链表的状态%d\n",isEmpty(head));   // 0代表非空 
 	//对链表进行删除
	 deleteList(head);
	 printf("对链表进行删除之后,链表的状态%d\n",isEmpty(head)); //对链表进行删除之后，1代表空 
 	
	return 0;	
}

测试结果：

0==false,代表非空，1==true代表空。

使用二级指针的测试结果：

使用一级指针的测试结果：

分析原因：

至此，我们应该弄明白了，链表函数的形参什么时候用一级指针，什么时候用二级指针，以及为什么要用一级指针，为什么要用二级指针。因为不是专业学C\C++的，对C++的理解并不太深，如果有哪写的不对不严谨的地方，还望指出。

下面仅贴出链表剩余操作相关代码：

链表的查询操作(按位查询)   T(n)=O(n)   使用一级指针

//按位查询  T(n) = O(n)
LNode * GetElem(LNode *list,int i){
	if(list==null) return null;
	if(i<0) return false;
	LNode *p = list;
	int j = 0;
	while(p!=null && j<i){
		p=p->next;
		j++;
	}
	return p;
}

链表的查询操作(按值查询)   T(n)=O(n)   使用一级指针

//按值查询  T(n)=O(n)
LNode * LocateElem(LNode *list,ElemType e){
	if(list == null) return false;
	LNode *p = list->next;
	while(p!=null && p->data != e){
		p=p->next;
	}
	return p;
}

链表的删除操作(后删)    T(n)=O(1)    使用一级指针

//链表的后删操作      T(n)=O(1)
bool deleteElem2(LNode *p,ElemType *e){
	if(p==null) return false;
	*e = p->data;
	LNode *q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return true;
}

链表的删除操作(前删)   

方式一：找到要删除元素的前驱结点，修改前驱结点的指向即可。  T(n) =O(n)   使用一级指针

//链表前删操作  T(n)=O(n)
bool deleteElem1(LNode *list,LNode *p, ElemType *e){
	if(p==null) return false;
	while(list->next!=null && list->next!=p){
		list=list->next;
	}
	if(list->next==null){
		return false;
	}
	*e = p->data;
	list->next = p->next;
	free(p);
	return true;
}

方式二:将后一个元素的值赋值给当前元素，删除后一个元素即可 T(n) =O(1)  使用一级指针   删除最后一个元素不适用。 

//链表元素前删  T(n) = O(1)
bool deleteElem2(LNode *p,ElemType *e){
	if(p==null) return false;
	*e = p->data;
	LNode *q = p->next;
	p->data = q->data;
	p->next = q->next;
	free(q);
	return true;
}

链表的删除操作(保留头结点)   T(n) =O(n)   使用一级指针。

//链表的删除操作(保留头结点)   T(n)=O(n)
void deleteList(LNode *head){
	if(head->next == null){
		printf("该链表已经被删除了\n");
		return;
	}
	while(head->next!=null){
	LNode *p = head->next;
	head->next = p->next;
	free(p);
	}
}

链表的插入操作(后插)  T(n)=O(1)   使用一级指针

//链表的插入操作(后插)  T(n)=O(1)
bool insertAfterP(LNode *p,ElemType e){
	if(p==null) return false;
	LNode *s =(LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return true;
}

链表的插入操作(前插) 

方式一：循环找到前驱结点并插入 T(n) = O(n)  使用一级指针

//链表的前插 T(n) = O(n)
bool insertPriorP1(LNode *list,LNode *p,ElemType e){
	if(p==null) return false;  
	while(list->next!=null && list->next!= p){
		list=list->next;
	}
	if(list->next==null){
		return false;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;
	s->next = list->next;
	list->next = s;
	return true;
}

方式二：直接后插，并且交换两元素的值 T(n) = O(1)   使用一级指针

//链表的插入(前插)   T(n) = O(n)
bool insertPriorP2(LNode *p,ElemType e){
	if(p==null) return false;
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->next = p->next;
	p->next = s;
	s->data = p->data;
	p->data = e;
	return e;
}

冯志佳
关注
  • 16
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
【数据结构】深入浅出理解链表中二级指针的应用
C/C++领域,数据结构,linux,MySQl学习者
11-22 1723
本文通过对单链表结构的分析,以及大量逻辑图示,物理图示详细解析了什么是二级指针?为什么链表要用到二级指针?为什么同样是链表的函数,有的要用二级指针而有的只要用一级指针?为什么同样是链表,有的链表中使用了二级指针?而有的函数却只需要使用一级指针?等问题.
链表中头结点必须为二级指针及原因
u013913482的博客
10-03 1325
链表操作
单链表的增删查改
mmz123_的博客
10-23 118
链表的概念及结构 概念： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 顺序表优点： 支持随机访问。（用下标直接访问第i个元素） 有些算法，需要结构支持随机访问。比如：二分查找，优化的快排等等。 顺序表缺陷： 空间不够了需要增容，增容是有代价的。 避免频繁扩容，一般都是依次是扩容2倍，可能就会导致一定的空间浪费。 顺序表要求数据从开始位置连续存储，那么我们在头部或者中间位置插入删除数据就需要挪动数据，效率不高。 针对顺序表缺陷，就设计出的链
链表中二级指针作用（图示）
yuanfuli的博客
11-03 2605
链表二级指针问题前提知识变量内存中都有自己的地址初始化链表需要双指针使用双指针情况使用单指针情况 前提知识 这个问题比较像函数传递时的值传递和引用传递类似，具体可以看下面两段代码，方便理解后面双指针。可以看到输出结果左侧还是6，而右侧输出0，这就是关键所在。形参m只是实参a的一个赋值的变量，形参我们都知道是函数调用时候才分配内存单元，当函数调用完毕后，形参就会被释放掉，所以左侧程序可以这么理解：定...
为什么链表创建使用二级指针
gentle_zou的博客
09-15 476
二级指针创建链表
商品管理系统&链表实现&二级指针
最新发布
11-15
在本系统中，二级指针可能用于操作链表的指针本身，例如更改链表的头节点或者在链表中进行更复杂的操作。二级指针可以被视为指向指针的指针，它可以用来间接修改指针的值。例如，如果我们有一个指向链表头的指针`...
c++2级指针的使用
05-17
总之，2级指针在C++中是一个强大的工具，虽然它们增加了代码的复杂性，但正确使用可以解决许多高级编程问题。理解和熟练掌握2级指针，对于提升C++编程技能至关重要。在实践中，需要注意内存管理，确保正确地分配和...
计算机二级C++基础知识.doc
11-16
计算机二级C++基础知识涵盖了许多核心概念，其中包括算法和数据结构。算法是问题求解的步骤描述，必须具备确定性、有穷性、可行性以及足够的信息。算法的效率通过时间复杂度和空间复杂度来衡量，前者关注计算工作量...
2020计算机二级考试C++考试内容.pdf
03-23
计算机二级考试C++是针对C++编程语言的资格认证，主要测试考生的程序设计能力、基础知识和软件工程实践。以下是对考试内容的详细说明： **一、基本数据结构与算法** 1. **算法**：理解算法的基本概念，包括时间...
2008计算机二级C++精选复习题.doc
11-16
- 问答题中提到了链表节点的插入操作，这涉及到链表的基本操作，如查找插入位置、更新指针等。 6. C++类和析构函数： - 解答中提到的析构函数是C++中负责清理对象资源的特殊成员函数。在类Stack的析构函数中，...
单链表的各种操作，包括使用二级指针创建单链表
12-01
使用二级指针创建单链表，程序功能菜单如图所示void showMenu(){ printf("\t\t\t\t\t\t1.使用头插法创建链表\n"); printf("\t\t\t\t\t\t2.使用尾插法创建链表\n"); printf("\t\t\t\t\t\t3.按序号查找\n"); printf("\t\t\t\t\t\t4.按值查找\n"); printf("\t\t\t\t\t\t5.按值插入\n"); printf("\t\t\t\t\t\t6.按位置插入\n"); printf("\t\t\t\t\t\t7.删除链表\n"); printf("\t\t\t\t\t\t8.测试链表并获得长度\n"); printf("\t\t\t\t\t\t9.将单链表倒置\n"); }
数据结构--用二级指针初始化单链表(c语言版)
sdmdnf的博客
04-15 186
L里面存放的是node的地址，给*L分配动态空间，使得他可以访问链表的数据域跟指针域。这里，我们通过重定义一个指针类型*linklist，指向结构体,在主函数中给他重命名为L。上一篇博客中，介绍到两种初始方式，用返回值来初始化，用二级指针来初始链表。因此，就可以通过*L（二级指针）对链表内容初始化了。最后其余插入方法跟输出方法基本一致。今天着重介绍二级指针初始化链表。
对单链表和带头双向循环链表的理解（二级指针问题）
m0_61227789的博客
08-07 450
在数据结构中，链表是一个非常重要的内容，而链表可以分为带头和不带头，循环和不循环，单向和双向，今天我们将介绍最常用的两种——无头单向非循环链表和带头双向循环链表，掌握了这两种，那么另外几种也就可以举一反三了。...
用二级指针删除链表
Arvin_success的博客
12-20 961
前几天在网上查找资料是看到了有大牛用二级指针操作链表，然后呢，我也在此写出来与大家分享一下，同时呢也做一下笔记。 一般的,我们都是用一级指针做删除链表的工作，如下： typedef struct node { struct node * next; .... } node; typedef bool (* remove_fn)(node const * v); // R
链表中进行“插入”，“删除”以及“初始化”时一级指针和二级指针的合理应用
qq_52276036的博客
08-18 437
1.首先，得明白指针的含义 一个链表的 头指针 就是指向链表头节点的指针（即存储链表第一个结点的地址） 指针变量就是存储地址的变量； 如： int * p; 它的含义就是：p是指向一个数据类型为int型的指针（即p存储一个int型数据的地址） 同理：ListNode *phead就表示phead是一个指向数据类型为 ListintNode （即phead存储一个ListNode 型数据的地址） 型的指针； 2.具体分析： （1）当链表为空时，对其进行插入或者初始化操作时，传入函数的变量应该为头指针的
二级指针的申请跟删除(基于C++的new机制)
walsfy168的博客
09-24 4027
#include #include #include using namespace std; #define FORi(N) for(int i=0;i!=N;i++) #define FORj(N) for(int j=0;j!=N;j++) #define El <<endl int main(){ int ** iptr = new int*[3]; int* tempPtr
单链表详解(由浅入深，含有源代码，带你玩转单链表和二级指针)
qq_65641647的博客
11-14 639
单链表详解，由浅入深，带你玩转单链表和二级指针，内含源代码可以直接用。
单链表的创建--头插法和尾插法
RanZLupup的博客
06-09 857
大佬们看看我这个单链表的创建哪里有问题呀，为啥头插法的第一个数和尾插法的最后一个数显示乱码呀！谢谢啦(#.#) #include<stdio.h> #include<iostream> #include<cstring> #include<cstdlib> using namespace std; typedef int ElemType; typedef struct LNode{ ElemType data; //存放元素值 struct L
数据结构单链表之创建链表（头插法）
Jeremy_Ren的博客
12-19 7958
数据结构的单链表的创建分为两种，分别为头插法和尾插法，本篇文章展示一种头插法的程序： 1.首先创建一个空链表结构体struct listnode { //链表成员的结构体，含有节点和指针，而链表的第一个成员称为头节点和头指针 int value; //节点 其中头节点的数据可以为空 listnode* next; //指向下一个链表成员的指针，所以也是listnode类型

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值