004——双向链表和循环链表

已于 2024-09-11 10:04:47 修改
阅读量571 收藏 11
点赞数 11
分类专栏： 数据结构 文章标签： 链表 数据结构
于 2024-09-10 22:39:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/immnature/article/details/142091950
版权

目录

双向链表

双向链表的初始化（与单链表类似）

增：

Ⅰ）头插法

Ⅱ）尾插法

Ⅲ）中间插入

删

改

查

整体代码示例：

 循环链表

循环单链表

​编辑 循环双链表

双向链表

不同于单链表，双向链表不仅可以往后指向，还可以往前指向，则双向链表是在单链表的基础上，每个结点增加一个指针域，这个指针域保存上一个结点的地址

pre指针域

（保存前一个结点的地址）

  数据域

    data

next指针域

（保存后一个结点的地址）

//双向链表的结构体
typedef struct Node {
	struct Node* pre;//增加保存前一个地址的结点
	int data;
	struct Node* next;
}Node,*LinkList;

 由003——单链表可知，单链表分为带头结点的不带头结点的，双向链表也是同理（上图的是带头结点的）

双向链表的初始化
（与单链表类似）

LinkList InitLinkList() {
	Node* p = (Node*)malloc(sizeof(Node));//申请头结点
	if (p == NULL) {
		printf("空间分配失败\n");
	}
	else {
		//p->data	脏数据，不用管
		p->pre=p->next = NULL;
		//注意：该语句的执行方向是从右往左
		/*
		p->pre = NULL;
		p->next = NULL;
		*/
	}
	return p;
}
int main() {
	LinkList L = InitLinkList();
}

增：

双向链表中增加一个结点（数据）

Ⅰ）头插法

固定在头结点和首元结点之间插入一个结点（头结点之后）如下图的例子

为了方便分析，我们为示意图进行编号 

注意，在这里对数据进行处理时，我们不能使得这个线（单向的，无论是正向还是负向）断掉，比如像下面这种情况，就是错误的

正确的顺序应该是先处理③和④，然后再处理①和②（顺序并不唯一）

 （下面代码并不完整）

//头插法：
LinkList HeadInsert(LinkList L, int k) {
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败/n");
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		
		s->pre = L;//3
		s->next = L->next;//4
		L->next= s;//1
		s->next->pre = s;//2

	}
	return L;
}

或者可以写成3421（还有其他写法）

        s->pre = L;
        s->next = L->next;
        L->next->pre = s;
        L->next = s;

此时还要考虑L为空的情况，因为这个时候的②是不存在的，所以最好将修改②这条线路更改放到最后

所以在我们更改②这条线之前，需要进行一个判断

//头插法：
LinkList HeadInsert(LinkList L, int k) {
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败/n");
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->pre = L;//3
		s->next=L->next;//4
		L->next = s;//1
		if (s->next != NULL) {
			s->next->pre = s;//2
		}
	}
	return L;
}

        s->data = k;//将数据传给新申请的结点s


        s->pre = L;//3


        s->next=L->next;//4


        L->next = s;//1


        if (s->next != NULL) {
            s->next->pre = s;//2
        }

Ⅱ）尾插法

从头结点开始遍历找到尾结点，在尾结点的后面插入新的结点（需要多维护一个pre）

//尾插法
LinkList RearInsert(LinkList L, int k) {
	Node* p = L;	//指针指p向头结点
	while (p->next != NULL) {
		p = p->next;
	}
	//循环结束后指针p指向最后一个结点
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败\n");
		return L;
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->next = p->next;
		s->pre = p;
		p->next = s;

	}
	return L;
}

Ⅲ）中间插入


//中间插入
//首先需要一个查找函数,并且返回该结点的地址
Node* find(LinkList L, int k) {
	Node* p = L->next;
	while (p != NULL && p->data != k) {
		//出现NULL->data!=k会报错，所以这两项的顺序不可以颠倒
		p = p->next;
	}
	return p;//要么为空，要么保存所要数据
}
//中间插入的函数
Node* MidInsert(LinkList L, int x, int k) {
	//在元素x后面插入数据k
	Node* p = find(L, x);
	if (p == NULL) {
		printf("数据%d不存在,无法找到插入位置，插入失败\n", x);
		return L;
	}
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败，插入失败\n");
		return L;
	}
	else {
		s->data = k;
		s->next = p->next;
		p->next = s;
		if (s->next != NULL) {
			s->next->pre = s;
		}
	}
	return L;
}

删

删除如下面图示

修改后的结果

//删除
LinkList Delete(LinkList L, int k) {
	if (L->next == NULL) {
		printf("空链表，删除失败\n");
		return L;
	}
	//找到k所在的结点p
	Node* p = find(L, k);
	if (p == NULL) {
		printf("数据%d不存在，删除失败\n");
		return L;
	}
	//删除
	p->pre->next = p->next;
	if (p->next != NULL) {
		p->next->pre = p->pre;
	}
	//防止p成为空指针
	free(p);
	p = NULL;
	return L;
	
}

改

修改代码与单链表是相同的

//修改
LinkList Replace(LinkList L, int x, int k) {
	Node* p = find(L, x);
	if (p == NULL) {
		printf("数据%d不存在，无法找到修改位置，修改失败\n", x);
		return L;
	}
	else {
		p->data = k;
	}
	return L;
}

查

查找代码与单链表是相同的

Node* find(LinkList L, int k) {
	Node* p = L->next;
	while (p != NULL && p->data != k) {
		//出现NULL->data!=k会报错，所以这两项的顺序不可以颠倒
		p = p->next;
	}
	return p;//要么为空，要么保存所要数据
}

整体代码示例：

#include<stdio.h>
#include<stdlib.h>
//双向链表的结构体
typedef struct Node {
	struct Node* pre;
	int data;
	struct Node* next;
}Node,*LinkList;

LinkList InitLinkList() {
	Node* p = (Node*)malloc(sizeof(Node));//申请头结点
	if (p == NULL) {
		printf("空间分配失败\n");
	}
	else {
		//p->data	脏数据，不用管
		p->pre=p->next = NULL;
		//注意：该语句的执行方向是从右往左
		/*
		p->pre = NULL;
		p->next = NULL;
		*/
	}
	return p;
}

//头插法：
LinkList HeadInsert(LinkList L, int k) {
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败/n");
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->pre = L;//3
		s->next=L->next;//4
		L->next = s;//1
		if (s->next != NULL) {
			s->next->pre = s;//2
		}
	}
	return L;
}

//尾插法
LinkList RearInsert(LinkList L, int k) {
	Node* p = L;	//指针指p向头结点
	while (p->next != NULL) {
		p = p->next;
	}
	//循环结束后指针p指向最后一个结点
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败\n");
		return L;
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->pre = p;//3
		s->next = p->next;//4
		p->next = s;//1
		if (s->next != NULL) {
			s->next->pre = s;//2
		}

	}
	return L;
}


//中间插入
//首先需要一个查找函数,并且返回该结点的地址
Node* find(LinkList L, int k) {
	Node* p = L->next;
	while (p != NULL && p->data != k) {
		//出现NULL->data!=k会报错，所以这两项的顺序不可以颠倒
		p = p->next;
	}
	return p;//要么为空，要么保存所要数据
}
//中间插入的函数
Node* MidInsert(LinkList L, int x, int k) {
	//在元素x后面插入数据k
	Node* p = find(L, x);
	if (p == NULL) {
		printf("数据%d不存在,无法找到插入位置，插入失败\n", x);
		return L;
	}
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败，插入失败\n");
		return L;
	}
	else {
		s->data = k;
		s->next = p->next;
		p->next = s;
		if (s->next != NULL) {
			s->next->pre = s;
		}
	}
	return L;
}

//修改
LinkList Replace(LinkList L, int x, int k) {
	Node* p = find(L, x);
	if (p == NULL) {
		printf("数据%d不存在，无法找到修改位置，修改失败\n", x);
		return L;
	}
	else {
		p->data = k;
	}
	return L;
}

//删除
LinkList Delete(LinkList L, int k) {
	if (L->next == NULL) {
		printf("空链表，删除失败\n");
		return L;
	}
	//找到k所在的结点p
	Node* p = find(L, k);
	if (p == NULL) {
		printf("数据%d不存在，删除失败\n");
		return L;
	}
	//删除
	p->pre->next = p->next;
	if (p->next != NULL) {
		p->next->pre = p->pre;
	}
	//防止p成为空指针
	free(p);
	p = NULL;
	return L;
	
}


void show(LinkList L) {
	Node* p = L->next;
	while (p != NULL)
	{
		printf("%d\t", p->data);
		p = p->next;
	}
}

int main() {
	LinkList L = InitLinkList();
	L = HeadInsert(L, 10);
	L = HeadInsert(L, 22);
	L = HeadInsert(L, 16);
	L = HeadInsert(L, 45);
	L = RearInsert(L, 77);
	L = MidInsert(L, 77,99);
	L = Delete(L, 10);
	show(L);
	return 0;

}

运行结果

 循环链表

循环单链表

循环链表只需要让最后一个结点的指针域指向头结点

 那么循环链表和单链表几乎没有太大差异,只是在为空的一些位置改成头结点

#include<stdio.h>
#include<stdlib.h>
typedef struct Node {
	int data;		//该节点的数据
	struct Node* next;		
}Node,*LinkList;


//初始化一个带头结点的空的循环链表
LinkList InitLinkList() {
	Node* s = (Node*)malloc(sizeof(Node));//申请头结点
	if (s == NULL) {
		printf("空间分配失败\n");
	}
	else {
		//s->data	脏数据，不用管
		s->next = s;//改变。。。。。。。。。。。。
	}
	return s;
}


//头插法：
LinkList HeadInsert(LinkList L, int k) {
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败/n");
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->next = L->next;
		L->next = s;
	}
	return L;
}

//尾插法
LinkList RearInsert(LinkList L, int k) {
	Node* p = L;	//指针指p向头结点
	while (p->next != L) {//改变。。。。。。。。。。。。
		p = p->next;
	}
	//循环结束后指针p指向最后一个结点
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败\n");
		return L;
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->next = p->next;//改变。。。。。。。。。。。。
		p->next = s;
	}
	return L;
}

//中间插入
//首先需要一个查找函数,并且返回该结点的地址
Node* find(LinkList L, int k) {
	Node* p = L->next;
	while (p!=L && p->data != k) {//改变。。。。。。。。。。。。
//出现NULL->data!=k会报错，所以这两项的顺序不可以颠倒
		p = p->next;
	}
	return p;//要么为空，要么保存所要数据
}
//中间插入的函数
Node* MidInsert(LinkList L, int x, int k) {
	//在元素x后面插入数据k
	Node* p = find(L, x);
	if (p == L) {//改变。。。。。。。。。。。。
		printf("数据%d不存在,无法找到插入位置，插入失败\n",x);
		return L;
	}
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败，插入失败\n");
		return L;
	}
	else {
		s->data = k;
		s->next = p->next;
		p->next = s;
	}
	return L;
}

//修改
LinkList Replace(LinkList L, int x, int k) {
	Node* p = find(L, x);
	if (p == L) {//改变。。。。。。。。。。。。
		printf("数据%d不存在，无法找到修改位置，修改失败\n", x);
		return L;
	}
	else {
		p->data = k;
	}
	return L;
}

//删除
LinkList Delete(LinkList L, int k) {
	if (L->next == L) {//改变。。。。。。。。。。。。
		printf("数据%d不存在，删除失败\n", k);
		return L;
	}
	//找到k所在的结点p和上一个结点
	Node* pre = L;
	Node* p = L->next;
	while (p!=L&&p->data!=k)//改变。。。。。。。。。。。。
	{
		pre = p;
		p = p->next;
	}
	if (p == L) {//改变。。。。。。。。。。。。
		printf("数据%d不存在，删除失败\n", k);
		return L;
	}
	pre->next = p->next;
	free(p);
	p = NULL;//防止p成为野指针
	return L;
}

void show(LinkList L) {
	Node* p = L->next;
	while (p!= L)//改变。。。。。。。。。。。。
	{
		printf("%d\t", p->data);
		p = p->next;
	}
}
int main() {
	LinkList L = NULL;
	L = InitLinkList();
	L=HeadInsert(L,10);
	L = HeadInsert(L, 8);
	L = RearInsert(L, 15);
	L = MidInsert(L, 5, 55);
	L=Replace(L, 8, 88);
	L = Delete(L, 8);
	show(L);
	return 0;
}

运行结果：

 循环双链表

循环双链表与之同理


#include<stdio.h>
#include<stdlib.h>
//双向链表的结构体
typedef struct Node {
	struct Node* pre;
	int data;
	struct Node* next;
}Node, * LinkList;

LinkList InitLinkList() {
	Node* p = (Node*)malloc(sizeof(Node));//申请头结点
	if (p == NULL) {
		printf("空间分配失败\n");
	}
	else {
		//p->data	脏数据，不用管
		//	p->next=p->pre=p;
		p->next = p;
		p->pre = p;
	}
	return p;
}

//头插法：
LinkList HeadInsert(LinkList L, int k) {
	//先申请一个新的结点用来保存数据k
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL) {
		printf("空间分配失败/n");
	}
	else {
		s->data = k;//将数据传给新申请的结点s
		s->pre = L;//3
		s->next = L->next;//4
		L->next = s;//1
		s->next->pre = s;//2
	}
	return L;
}

//尾插法
LinkList RearInsert(LinkList L, int k) {
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
	{
		printf("空间分配失败\n");
		return L;
	}
	s->data = k;

	//找尾节点
	Node* p = L;
	while (p->next != L)
	{
		p = p->next;
	}
	s->next = p->next;
	s->pre = p;
	p->next = s;
	s->next->pre = s;
	return L;
}


//中间插入
//首先需要一个查找函数,并且返回该结点的地址
Node* find(LinkList L, int k) {
	//查找数据k所在的节点，并且返回该节点的地址 
	Node* p = L->next;
	while (p != L && p->data != k)
	{
		p = p->next;
	}
	return p;
}
//中间插入的函数
Node* MidInsert(LinkList L, int x, int k) {
	//数据x后插入数据k 
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
	{
		printf("空间分配失败\n");
		return L;
	}
	s->data = k;
	//找x所在节点 
	Node* p = find(L, x);
	if (p == L)
	{
		printf("数据%d不存在，插入失败\n", x);
		return L;
	}
	s->pre = p;//3
	s->next = p->next;//4
	p->next = s;//1
	s->next->pre = s;//2
	return L;

}

//修改
LinkList Replace(LinkList L, int x, int k) {
	Node* p = find(L, x);
	if (p == L) {
		printf("数据%d不存在，无法找到修改位置，修改失败\n", x);
		return L;
	}
	else {
		p->data = k;
	}
	return L;
}

//删除
LinkList Delete(LinkList L, int k) {
	if (L->next == L)
	{
		printf("空链表，删除失败\n");
		return L;
	}
	//找k所在的节点p
	Node* p = find(L, k);
	if (p == L)
	{
		printf("数据%d不存在，删除失败\n", k);
		return L;
	}
	//删除：
	p->pre->next = p->next;
	p->next->pre = p->pre;

	free(p);
	p = NULL;
	return L;
}


void show(LinkList L) {
	Node* p = L->next;
	while (p != L)
	{
		printf("%d\t", p->data);
		p = p->next;
	}
}

int main() {
	LinkList L = InitLinkList();
	L = HeadInsert(L, 10);
	L = HeadInsert(L, 22);
	L = HeadInsert(L, 16);
	L = HeadInsert(L, 45);
	L = RearInsert(L, 77);
	L = MidInsert(L, 77, 99);
	L = Delete(L, 10);
	show(L);
	return 0;

}

 运行结果：

--JR
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构系列2——双向链表和双向循环链表
喜欢C艹的小白的博客
09-23 4907
引入：双向链表是在原来的单链表基础上增加了一个可以保存某节点的上一个节点的指针域的数据结构，相较于单链表而言，双向链表在查找数据的时候所花费的时间是要小于单链表的，因为其可进可退。其缺点就是增删节点比单链表麻烦，而且在创建节点的时候也需要多申请一个指针存储空间。双向循环链表，顾名思义就是在双向链表的基础上，将尾节点的“right”指针指向头结点，同时头结点的“left”指针指向尾节点，它和双向链表的不同是，其判断节点是否遍历完毕的条件不再是是否为空，而是是否回到了头结点，优点是可以在任意位置插入数据，时间.
数据结构——双向链表、循环链表
龍弟-idea的博客
11-29 3292
目录 双链表的实现 java中LinkedList实现 链表的复杂度分析 循环链表 双向链表，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null...
线性表——循环链表和双向链表
weixin_52677033的博客
05-21 342
特点：表中的最后一个结点的指针域指向头结点，整个链表形成一个环。与普通的线性链表的操作基本一致，差别在于循环条件不是p或p->next 是否为空，而是它们是否等于头指针。由于以上讨论的线性链表结构都是只有一个直接指向后继结点的指针域，所以遍历的方式都是只能从某一个结点向后遍历，为了克服这一个缺点，可以使用。双向链表的结点有两个指针域，一个指向直接后继结点，一个指向直接前驱结点。指针指向原链表头节点的下一个节点，并更新原链表头节点的后继指针指向。的前驱指针指向原链表头节点，完成节点的插入操作。
数据结构——双向链表 与 循环链表
Zhang_Qin123的博客
12-08 899
指针域：front，next数据域：相关元素数据int num,id;}student;
数据结构——双向链表
麦麦的博客
03-11 2233
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
线性表——循环链表、双向链表
m0_53359491的博客
12-07 582
目录一、循环链表1、定义和特点 2、初始化循环链表 3、求循环链表的长度4、遍历循环链表找到值为x的结点个数（重点在于遍历操作）5、循环链表的典型应用——约瑟夫环 二、双向链表1、定义和特点 2、双向链表的类型声明3、求双向循环链表的长度 4、双向循环链表插入算法5、双向循环链表删除结点算法 注：以下算法中循环链表的节点声明同单链表 3、求循环链表的长度 4、遍历循环链表找到值为x的结点个数（重点在于遍历操作） 5、循环链表的典型应用——约瑟夫环 题解代码： 运行结果
数据结构——双向循环链表
qq_67611811的博客
08-28 2175
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
线性表的应用 —— 双向链表 && 循环链表
谢谢你们的关注
09-12 451
线性表的应用 —— 双向链表 && 循环链表
面试八股之集合篇4.2——链表——双向链表及其复杂度分析
做一个善良的人，做好自己的事，如果愿意，再发一份光。
05-31 794
🔥本篇概览：详细讲解了双向链表及其复杂度分析。
数据结构基础——双向链表
XXXTENTAC1ON的博客
04-11 540
双向链表什么是双向链表双向链表的实现1、结构的声明2、方法的声明3、方法的实现 什么是双向链表 首先，双向链表一样是链表，逻辑上存储连续，物理上存储不连续。但是相对于单链表每个结点存储两个数据（data 数据 next 下一个结点的地址），双向链表每个结点存储三个数据，比普通链表多 prior 储存上一结点的地址。 双向链表的每个结点除了存储后一个结点的地址，还需要存储前一个结点的地址。 – 从前向后遍历和从后向前遍历 双向链表的实现 1、结构的声明 typedef double DataType
特殊的链表——双向、循环、静态
01-20
本文将深入探讨一种特殊类型的链表，包括双向链表、循环链表以及静态链表，它们各自拥有独特的特性和操作方式。 首先，**双向链表**与常见的单链表不同，每个节点不仅包含一个指向后继节点的指针，还包含一个指向...
20多张无水印图熟练理解和掌握单链表-双向链表-循环链表（原理+C源码）
05-29
顺序存储和链式存储 1 数组—顺序存储 1 链表—链式存储 2 链表概述 3 单链表 4 单链表概念和简单的设计 4 链表的初始化 5 头插入法创建单链表 6 ...进阶概念——双向循环链表 23 关于链表的总结 23
数据结构学习——双向链表
YiHeboy的博客
07-05 877
双向循环链表的创建及增删改查
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3181
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
【数据结构】——1.1树
qq_43507078的博客
09-07 944
树，二叉树
CSP-J 算法基础 排序算法的基本概念
m0_62599305的博客
09-10 749
排序算法是计算机科学中最基础的算法之一，广泛应用于数据处理、搜索、优化等各种场景。排序的目的是将一组数据按一定的顺序（通常是升序或降序）排列，以便后续的高效处理。常见的排序算法有很多种，每种算法都有其特点和适用场景。本文将介绍排序算法的基本概念，并总结这些算法的优缺点和应用场景。排序算法的稳定性就是看相同值的元素在排序后是否保持原来的顺序。稳定排序算法确保了相同值元素的相对位置不会改变，而不稳定排序算法则可能会改变它们的相对顺序。理解这一点可以帮助你选择合适的排序算法来满足特定的需求。有序度。
数据结构10
最新发布
m0_52024881的博客
09-10 144
假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点(k为正整数)。若查找成功，算法输出该结点的data域的值，并返回1;（3）根据设计思想和实现步骤，采用程序设计语言描述算法(使用C、C++或Java语言实现)，关键之处请给出简要注释。这里需要注意一下递归出现的位置。（1）描述算法的基本设计思想。（2）描述算法的详细实现步骤。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 613
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
栈—数据结构
weixin_63722559的博客
09-06 1007
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值