数据结构之单链表

最新推荐文章于 2023-11-03 11:28:07 发布
最新推荐文章于 2023-11-03 11:28:07 发布
阅读量672 收藏 40
点赞数 51
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58963318/article/details/133347483
版权

目录

前言：

链表的定义与结构

单链表的接口实现

显示单链表

创建新结点

单链表尾插

头插的实现简单示例图

尾插经典错误示例1

尾插经典错误示例2

尾插函数的最终实现

 单链表头插

单链表尾删

单链表头删

单链表查找

单链表在pos位置之前插入数据x

​编辑

单链表在pos位置之后插入数据x

单链表删除pos位置的值

单链表删除pos位置之后的值

前言：

顺序表存在如下问题：

  • 顺序表在中间位置或者头部进行元素插入或者删除时，由于需要拷贝数据，导致时间复杂度为O(N)效率比较低
  • 增容需要申请新空间，拷贝数据，释放旧空间，尤其是异地扩容，会有不小的消耗；
  • 增容一般呈两倍增长，势必会有一定空间的浪费；

上述问题的解决方案会采用另一种线性结构 —— 链表

链表的定义与结构

定义：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的；

理解思路：链表中的每一个数据元素都是独立存储的，当需要存储一个数据元素时则向内存的堆区申请一块空间存储当前数据，每一个数据元素通过地址串联在一起；对于链表这个结构而言，不仅需要存储当前的数据元素，而且需要存储下一个元素的地址，这样才能实现数据元素的串联；通常将待存储的数据元素和下一个数据的地址合起来称为链表中的一个节点；

示例图：


注意事项：

  1. 链式结构在逻辑上是连续的，但是在物理结构上不一定连续；
  2. 结点一般都是在内存的堆区申请；
  3. 堆上申请的空间是按照一定的策略分配，俩次申请的空间可能连续，也可能不连续；
typedef int SLTDatatype;
typedef struct SListNode
{
	SLTDatatype data;//数据域
	struct SListNode* next;//存放下一个结点的地址-指针域
}SListNode;
//此结构体大小为8字节
int main()
{

       //堆区开辟8字节的空间
	SListNode* p1 = (SListNode*)malloc(sizeof(SListNode));
       //结构体前四个字节存放数据
	p1->data = 10;

	SListNode* p2 = (SListNode*)malloc(sizeof(SListNode));
	p2->data = 20;

	SListNode* p3 = (SListNode*)malloc(sizeof(SListNode));
	p3->data = 30;
       //结构体后四个字节存放下一个结点的地址
	p1->next = p2;
	p2->next = p3;
	p3->next = NULL;

	return 0;
}

 监视窗口：

由于结构体的大小为8字节，从上图可以看出申请的空间并不一定连续；

单链表的接口实现

数据结构无非是对数据进行管理，要实现数据的增删查改，因此链表的基本功能也是围绕数据的增删查改而展开；

显示单链表

顺序表传参时指针必不为空指针，而链表传参指针可能为空指针；

当链表中没有元素时，头指针所指向的就是空指针；（不可断言指针为空）

当链表中存在元素时，最后一个结点的指针域必存在空指针，当指针域的元素为空，停止打印；

void PrintSList(SListNode* phead)
{
	SListNode* cur = phead;
	while (cur != NULL )
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
  •  显示单链表测试
void Test1()
{
	SListNode* p1 = (SListNode*)malloc(sizeof(SListNode));
	p1->data = 10;
	SListNode* p2 = (SListNode*)malloc(sizeof(SListNode));
	p2->data = 20;
	SListNode* p3 = (SListNode*)malloc(sizeof(SListNode));
	p3->data = 30;

	p1->next = p2;
	p2->next = p3;
	p3->next = NULL;
	PrintSList(p1);
}
int main()
{
	Test1();
	return 0;
}

运行结果：

创建新结点

单链表进行头插尾插时，插入的是一个结点，这个结点包括SLTDatatype数据和SLTDatatype*的指针，为防止代码过于冗余，单独封装为BuySListNode()函数来创建新结点；

SListNode* BuySListNode(SLTDatatype x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}
  • 创建新结点测试
void Test2()
{
	SListNode* n1 = BuySListNode(10);
	SListNode* n2 = BuySListNode(20);
	SListNode* n3 = BuySListNode(30);

	n1->next = n2;
	n2->next = n3;
	PrintSList(n1);
}

int main()
{
	Test2();
	return 0;
}

运行结果：

单链表尾插

实现尾插之前，我们先看一个头插的简单的示例，并且认知实现尾插时的各种常见错误，分析具体原因，从而实现真正的尾插函数；

头插的实现简单示例图

假设1：链表中存在元素，如下图所示，如何实现头插？

             首先利用BuySListNode()函数来创建一个新结点newnode;

      其次只需要 newnode->next中的NULL变成pList,即newnode->next=pList;

最后使pList指向newnode,即pList=newnode；这样便完成链表的头插元素；

假设2: 链表中没有元素，如何实现头插？

         1. 首先利用BuySListNode()函数来创建一个新结点newnode;

      2. 其次只需要 newnode->next中的NULL变成pList,即newnode->next=pList;

      3.最后使pList指向newnode,即pList=newnode；这样便完成链表的头插元素；

    如上所得，链表中结点是否存在，对于头插的实现逻辑上没有任何区别；

尾插经典错误示例1

假设链表中存在结点，如何实现尾插?

  • 利用BuySListNode()函数来创建一个新结点newnode；
  • 找到最后一个元素（尾结点）；
  • 尾结点中的指针域赋值为newnode；

//下述代码正确吗？
void SLTpushback(SListNode* phead, SLTDatatype x)
{
	SListNode* newnode = BuySListNode(x);
	SListNode* tail = phead;
   //查找尾结点 
	while (tail != NULL)
	{
		tail = tail->next;
	}
  //尾插
	tail = newnode;
}

当调用SLTpushback()函数，操作系统会为该函数开辟函数栈帧，而phead(形式参数)，tail（局部变量），newnode（局部变量）的值全部保存在栈空间，但是形式参数只是实际参数的一份临时拷贝，即值是相同的，空间是独立的，改变形参并不会影响实参; 局部变量进入作用域创建，出作用域由于操作系统回收空间自动销毁；

  •  数据结构链表物理图（循环结束后内存布局）；

  • 执行tail=newnode后链表物理图；

  • SLTpushback()函数调用结束链表物理图

如上图所示，上述代码不仅没有实现尾插节点的功能 ，还导致了内存泄漏；

  •  假设链表中存在元素，实现尾插的思路如下：

尾插正确做法1(链表中存在元素)
结点是由malloc()函数在堆区申请的空间,改变堆区的数据随着函数栈帧的销毁数据并不会销毁，而形式参数，局部变量在栈空间上创建，函数栈帧销毁后随之销毁;只需要改变尾结点的指针域（存放于堆区），使得其指向新结点，从而就可以实现尾插;

//尾插正确思路(假设链表中存在元素)
void SLTpushback(SListNode* phead, SLTDatatype x)
{
	SListNode* newnode = BuySListNode(x);
	SListNode* tail = phead;

	while ((tail->next) != NULL)
	{
		tail = tail->next;
	}
    //修改尾结点的指针域
	tail->next = newnode;
}

尾插经典错误示例2

假设链表中没有结点，如何实现尾插？

  • 利用BuySListNode()函数来创建一个新结点newnode；
  • 头指针pList赋值为newnode;

链表为空实现尾插物理图

//下述代码正确吗？
void SLTpushback(SListNode* phead, SLTDatatype x)
{
	SListNode* newnode = BuySListNode(x);
	//链表为空,没有结点
	if (phead == NULL)
	{
		phead = newnode;
	}
	//链表不为空,存在结点
	else
	{
		SListNode* tail = phead;
		while ((tail->next) != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

 当链表为空时，希望实参pList指向新结点，但是phead为形式参数，对形参phead的修改不会影响实参plist, 而且phead出作用域自动销毁；具体见下图所示

  • 传参时物理图

  • 执行phead=newnode后的物理图

  • 函数调用结束后的物理图

 上述代码存在问题，它不但丢失了新创建的结点,而且没有修改实参pList，没有实现尾插；

尾插函数的最终实现

综合上述所有考虑，当链表为空时，为了能够修改实参pList(头指针），我们只能传址调用，那么就该采用二级指针来接收参数 ;

//尾插新结点
void SLTpushback(SListNode** pphead, SLTDatatype x)
{
	SListNode* newnode = BuySListNode(x);
	//链表为空,没有结点
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	//链表不为空,存在结点
	else
	{
		SListNode* tail = *pphead;
		while ((tail->next) != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
  • 单链表尾插测试
void Test()
{
	SListNode* pList = NULL;
	SLTpushback(&pList, 1);
	SLTpushback(&pList, 2);
	SLTpushback(&pList, 3);

	PrintSList(pList);
}
int main()
{
	Test();
	return 0;
}

 运行结果：

 单链表头插

正如前文所述，单链表中结点是否存在，对于头插的实现逻辑上没有任何区别，但是由于头插的过程中需要不断的改变单链表中的头结点，所以传参时需要头指针的地址，方便修改实参；

//头插新结点
void SLTpushfront(SListNode** pphead, SLTDatatype x)
{
	SListNode* newnode = BuySListNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}
  • 单链表头插测试
void Test()
{
	SListNode* pList = NULL;
	SLTpushfront(&pList, 10);
	SLTpushfront(&pList, 20);
	SLTpushfront(&pList, 30);
	SLTpushfront(&pList, 40);
	PrintSList(pList);
}
int main()
{
	Test();
	return 0;
}

运行结果：

单链表尾删

链表的核心特性在于前后关联，不能只考虑单个结点，如果只考虑单个结点，该结点前后的结点容易出现错误；比如实现尾删时，如果只想找到链表最后一个元素，进而释放尾结点的空间，但是尾结点的前一个节点的指针域并未置空，仍然指向一块未知空间，造成野指针；

假设链表中存在两个及两个以上的结点，如何实现尾删 ？

  • 首先找到尾结点的上一个节点 ；

  •  释放tail->next所指向的空间 ；

  • 将tail->next=NULL即可；

通过上述三个图，发现好像当单链表尾删传参时，并不需要二级指针；

假设链表中存在1个结点，如何实现尾删 ？ 

当链表中只有一个节点时，根本不存在前一个节点，上述针对多结点的方式已经失效；

当尾删掉这个节点之后，需要将pList置为空指针，如何改变pList ?

因此传参时只能传址调用，只有传址才能改变pList中的值；

所以当进行尾删时，只能传递二级指针；

当链表为空时不能进行尾删操作，因此需要对链表进行判空；

  • 单链表尾删实现方式一
void SLTpopback(SListNode** pphead)
{
    //单链表为空
	assert(*pphead != NULL);
   //单链表只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);//其实*pphead就是pList
		*pphead = NULL;
	}
   //单链表有多个结点
	else
	{
		SListNode* tailPrev = NULL;//记录尾结点的前一个结点
		SListNode* tail = *pphead; //寻找尾结点
		while (tail->next!=NULL)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;
	}
}
  •  单链表尾删实现方式2
void SLTpopback(SListNode** pphead)
{
	//单链表为空
	assert(*pphead != NULL);
	//单链表只有一个结点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);//其实*pphead就是pList
		*pphead = NULL;
	}
	//单链表有多个结点
	else
	{
		SListNode* tail = *pphead;
		while (tail->next->next!=NULL)
		{
			tail = tail->next;
		}

		free(tail->next);
		tail->next = NULL;
	}
}
  • 单链表尾删测试
void Test()
{
		SListNode* plist = NULL;
		SLTpushback(&plist, 11);
		SLTpushback(&plist, 22);
		SLTpushback(&plist, 33);
		PrintSList(plist);


		SLTpopback(&plist);
		PrintSList(plist);

		SLTpopback(&plist);
		PrintSList(plist);

		SLTpopback(&plist);
		PrintSList(plist);
}

int main()
{
	Test();
	return 0;
}

运行结果：

单链表头删

对链表进行头删操作，需要对链表的头结点进行改变,所以传参时需要传址调用，需要头指针的地址，因此参数为二级指针；链表为空不能进行头删操作，因此需要对链表进行判空；

  • 假设链表中存在两个及两个以上的结点，如何实现头删 ？

case 1： 如果直接释放首结点，通过pList无法查找到首节点的下一个结点；

case2：  如果让pList直接指向首结点的下一个节点，由于首结点丢失，无法释放首结点；

case 1：

case 2：

  • 单链表头删的实现方式
//单链表头删
void SLTpopfront(SListNode** pphead)
{
	//判空
	assert(*pphead!=NULL);
	//非空
	SListNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}
  •  单链表头删测试
void Test()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 10);
	SLTpushback(&plist, 20);
	SLTpushback(&plist, 30);
	PrintSList(plist);

	SLTpopfront(&plist);
	PrintSList(plist);

	SLTpopfront(&plist);
	PrintSList(plist);

	SLTpopfront(&plist);
	PrintSList(plist);
}
int main()
{
	Test();
	return 0;
}

运行结果：

单链表查找

按照数据进行查找，找到返回结点位置，找不到返回空指针；

SListNode* SListFind(SListNode* phead, SLTDatatype x)
{
	assert(phead != NULL);

	SListNode* cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
  • 单链表查找测试
void Test()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 10);
	SLTpushback(&plist, 20);
	SLTpushback(&plist, 30);
	SLTpushback(&plist, 40);
	SLTpushback(&plist, 50);
	printf("请输入要查找的值\n");
	int x = 0;
	scanf("%d", &x);
	SListNode* pos = SListFind(plist, x);
	if (pos != NULL)
	{
		pos->data = pos->data * 10;
	}
	PrintSList(plist);
}
int main()
{
	Test();
	return 0;
}

运行结果：

查找函数的接口既实现了查找的功能，又承担了修改数据的功能；

单链表在pos位置之前插入数据x

case 1:   pos位置处的结点就是首节点；需要改变头指针的值，传参时应该传址调用；

 

 

case 2：pos位置处的结点非首结点 ；需要查找pos位置的前一个节点，将前一个结点的指针域置为newnode;

 

void SListInsert(SListNode** pphead, SListNode* pos, SLTDatatype x)
{
	assert(pos != NULL);

	if (*pphead == pos)
	{
		SLTpushfront(pphead, x);
	}
	else
	{
		SListNode* posprev = *pphead;
		while (posprev->next != pos)
		{
			posprev = posprev->next;
		}
		SListNode* newnode = BuySListNode(x);
		newnode->next = pos;
		posprev->next = newnode;
	}
}
  • SListInsert() 函数测试
void Test9()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 1);
	SLTpushback(&plist, 2);
	SLTpushback(&plist, 3);
	SLTpushback(&plist, 4);
	SLTpushback(&plist, 5);

	int x = 0;
	scanf("%d", &x);
	SListNode* pos = SListFind(plist, x);
	if (pos != NULL)
	{
		SListInsert(&plist, pos, x*10);
	}
	PrintSList(plist);
}
int main()
{
	Test9();
	return 0;
}

运行结果：

单链表在pos位置之后插入数据x

当在pos位置之后插入数据，不需要查找前一个结点，只需要根据pos的位置就可完成插入；

 

void SListInsertAfter(SListNode* pos, SLTDatatype x)
{
	assert(pos != NULL);

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;

}
  •  SListInsertAfter()函数测试
void Test()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 1);
	SLTpushback(&plist, 2);
	SLTpushback(&plist, 3);
	SLTpushback(&plist, 4);
	SLTpushback(&plist, 5);

	int x = 0;
	scanf("%d", &x);
	SListNode* pos = SListFind(plist, x);
	if (pos != NULL)
	{
		SListInsertAfter(pos, x * 10);
	}
	PrintSList(plist);
}
int main()
{
	Test();
	return 0;
}

运行结果：

单链表删除pos位置的值

假设pos位置处的结点非首结点

  1.  查找pos位置处的前一个结点
  2.  将pos处的前一个节点的指针域赋值为pos后一个节点 ；
  3.  释放pos处的空间

假设pos位置为首结点，直接按照头删的逻辑处理；

void SListEarse(SListNode** pphead, SListNode* pos)
{
	assert(pos != NULL);

	if (*pphead == pos)
	{
		SLTpopfront(pphead);
	}
	else
	{
		SListNode* posprev = *pphead;
		while (posprev->next != pos)
		{
			posprev = posprev->next;
		}
		posprev->next = pos->next;
		free(pos);
	}
}
  • 单链表删除指定结点的值测试
void Test()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 1);
	SLTpushback(&plist, 2);
	SLTpushback(&plist, 3);
	SLTpushback(&plist, 4);
	SLTpushback(&plist, 5);
    PrintSList(plist);

	int x = 0;
	scanf("%d", &x);
	SListNode* pos = SListFind(plist, x);
	if (pos != NULL)
	{
		SListEarse(&plist, pos);
	}
	PrintSList(plist);
}
int main()
{
	Test();
	return 0;
}

运行结果：

单链表删除pos位置之后的值

void SListEarseAfter(SListNode* pos)
{
	assert(pos);

	// 检查pos是否是尾节点
	assert(pos->next);

	SListNode* posnext = pos->next;

	pos->next = posnext->next;

	free(posnext);
	posnext = NULL;

}
  • SListEarseAfter()函数测试
void Test()
{
	SListNode* plist = NULL;
	SLTpushback(&plist, 1);
	SLTpushback(&plist, 2);
	SLTpushback(&plist, 3);
	SLTpushback(&plist, 4);
	SLTpushback(&plist, 5);
	PrintSList(plist);

	int x = 0;
	scanf("%d", &x);
	SListNode* pos = SListFind(plist, x);
	if (pos != NULL)
	{
		SListEarseAfter(pos);
	}
	PrintSList(plist);
}
int main()
{
    Test()
    return 0;
}

运行结果:

小呆瓜历险记
关注
  • 51
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 29
    评论
如何在单链表中从尾部找到第三个节点?
一个程序媛的成长记录❤
09-08 2049
方法一： 从头遍历第一次，求出单链表长度L； 再遍历一次，第L-3+1个节点就是从尾部倒数第3个节点。 但这种方法需要遍历两遍。 方法二： 设要从尾部找第k个节点 定义两个指针p1和p2，它们之间间隔k-1个节点。p1和p2均从头节点开始，p1先走，等间隔k-1个节点后，p2再出发。 然后两个指针都继续移动，当p1移动到尾节点时，p2所在位置就是从尾部倒数第k个节点的位置。 这种做...
线性表技巧之Note001-链表的最后一个节点
二木成林
04-05 4482
线性表技巧之Note001-链表的最后一个节点
【PTA】【C语言】复盘练习——函数题
yewanyuan的博客
05-25 8222
目录 R6-1 最大公约数-递归 R6-2 猴子吃桃-递归 R6-3 奇妙的定律-递归 R6-4 删除单链表的第i个结点。 R6-5 链表-查找链表最后节点 R6-6 链表逆序 R6-7 结构体-查找最低分学生记录 R6-8 结构体-查找同学信息 R6-9 逆序输出字符串 R6-10 求整数区间[a,b]中偶数之和 R6-11 阶乘计算 R6-12 求10×10方阵主副对角线元素之和 R6-13 输入多个单词，统计以指定字母开头的单词个数 R6-14 求等差数列前n项和 R
数据结构之单链表（尾插法）查找、插入和删除
摩尔的博客
05-13 2168
这一次的难度主要体现在长，常常的代码让人望而生畏，不过，只要理解清楚了查找、插入和删除就好办了 代码#include<stdio.h> #include<malloc.h> typedef struct node { int data; struct node*next; }node; node*creat() { node*head,*q,*p; char ch;
数据结构----链表高阶
Mrstarcheng的博客
03-26 266
所谓双向循环带头链表可以分为以下3类来进行理解：首先是双向：双向表示后一个节点可以找到自己的前驱节点，这一点和单链表有本质的区别。其次是带头：若链表带头的话说明，链表有一个头结点，这个头结点也可称为哨兵位的头结点，该节点和普通节点一样，依然有自己的前驱和后继节点，但是头结点的data/val一般为随机值。最后是循环：循环链表指的是链表的尾结点的后继节点是头结点，头结点的前驱节点是尾结点。构成了一个大大的环状结构。
数据结构之单链表操作合集.zip
最新发布
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
使用C++实现链表数据结构之单链表.zip
03-13
链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在处理动态数据集合时。本主题将深入探讨如何使用C++语言实现单链表。单链表是链表的一种基本形式，每个节点包含数据和指向下一个节点的指针。 ...
Python数据结构之单链表详解
09-21
主要为大家详细介绍了Python数据结构之单链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于JAVA的数据结构之单链表操作合
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
单链表的基本操作——寻找尾结点
m0_75017568的博客
10-03 309
【代码】单链表的基本操作——寻找尾结点。
单链表的查找(按值查找、按位查找)(数据结构与算法)
AII_IIA的博客
11-03 4525
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
链表
我于万物之中
02-17 1031
定义链表节点 typedef struct Node{ int value; struct Node *next; //指针名为next,指针指向的类型为一个叫Node的结构体 }node; 插入元素操作 1.非函数版本 int number; cin>>number; node*head=NULL; /*↓↓创建一个新的链表节点 ↓↓*/ node*p=(nod...
数据结构---＞第二天，链表
qq_59476403的博客
06-22 246
链表 特点 地址可以不连续 大小不固定 删除和插入的时候，不需要移动元素，比较方便 访问不方便，只能从头结点开始访问 术语 单向 链表中任意一个结点，只有一个指针域，存放下一个结点的地址。 双向 链表中任意一个结点，有两个指针域，分别存放下一个结点的地址和前一个结点的地址。 ...
单链表基本学习
qq_43129608的博客
03-09 211
/** * 单链表 * @author Administrator * */ public class SingleLinkedListDemo { public static void main(String[] args) { // TODO Auto-generated method stub //创建节点 HeroNode heronode1=new HeroNode(1,"宋江","及时雨"); HeroNode ...
链表（创建，append（），寻找最后一个元素）
weiyusky2019的博客
03-03 146
【代码】链表（创建，append（），寻找最后一个元素）
链表--如何寻找单链表的中间结点
yangruxi的博客
05-16 2919
如何寻找单链表的中间结点 方法一 思路：从头到尾遍历链表，得到链表的长度length，求出length/2，就能找到单链表的中间结点。 方法二 思路：如果是双向链表，我们可以设置两个指针（Java中没有指针，但是引用和指针概念很像），一个从头开始遍历，一个从链表尾开始遍历，两个指针相遇的时候就是链表的中间结点。对于单链表，我们以此为基础，设置两个指针，一个指针一次走一步，另一个指针一次...
寻找单链表尾结点算法
算法与编程之美
03-28 3148
本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。问题描述结点p = head，设计算法让p指向链表的最后一个结点。示例：输入：p=head输出：...
通过遍历，找到链表中最后一个结点
weixin_44436675的博客
01-07 3762
通过遍历，找到链表中最后一个结点 首先创建一个链表，然后再找到链表的最后一个结点 代码实例： class Node { public int val; public Node next; public Node(int val) { this.val = val; } } public class MyLinkedList { public Node head;//普通引用，目的是让head一直指向当前列表的头 public void

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小呆瓜历险记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值