【顺序栈的实现1】--------含栈顶，栈底指针；栈顶指针指向栈顶元素的下一个位置

于 2024-08-20 19:17:49 发布
阅读量855 收藏 8
点赞数 22
分类专栏： 数据结构 文章标签： 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82676816/article/details/141363398
版权

1. 栈的抽象数据类型定义：

在这里插入图片描述

2.顺序栈的存储方式

同一般线性表的顺序存储结构完全相同：
利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。栈底一般在低地址端。

  • 附设top指针，指示栈顶元素在顺序栈中的位置
  • 另设base指针，指示栈底元素在顺序栈中的位置
  • 另外，用stacksize表示栈可使用的最大容量

但是，为了方便操作，通常top指向真正的栈顶元素 之上的 下标地址，如下图
在这里插入图片描述

3.顺序栈的相关基础操作汇总

  • 初始化操作：操作结果:构造一个空栈 S。
InitStack(SqStack* s)
  • 判定S是否为空栈：
    初始条件:栈S 已存在。
    操作结果:若栈S为空栈，则返回TRUE，否则 FALSE.
StackEmpty(SqStack s)
  • 求栈的长度
    初始条件:栈S 已存在。
    操作结果:返回S的元素个数，即栈的长度
StackLength(SqStack s)
  • 栈置空操作：
    初始条件:栈S 已存在。
    操作结果:将S清为空栈。
ClearStack(SqStack * s)
  • 销毁栈操作：
    初始条件:栈S 已存在。
    操作结果:栈S 被销毁。
DestroyStack(SqStack *s)
  • 入栈操作（重点）
    初始条件:栈S已存在且未满。
    操作结果:插入元素e为新的栈顶元素。
Push(SqStack* s, SElemType e)
  • 出栈操作（重点）
    初始条件:栈S 已存在且非空:
    操作结果:删除S的栈顶元素a.，并用e返回其值。
Pop(SqStack* s, SElemType* e)
  • 取栈顶元素
    初始条件:栈S 已存在且非空。
    操作结果:用e返回S的栈顶元素。
GetTop(SqStack s, SElemType* e)
  • 从栈顶开始输出整栈
    初始条件:栈S 已存在且非空。
    操作结果:从栈顶输出栈中所有元素。
printStack(SqStack s)

4.整栈操作模拟与异常分析

4.1操作模拟：

由于本篇中顺序栈含栈顶，栈底指针；并且栈顶指针指向栈顶元素的下一个位置
在这里插入图片描述
所以空栈与栈满的判断条件也有所不同：
在这里插入图片描述

4.2异常处理：

使用数组作为顺序栈存储方式的特点:
在这里插入图片描述
而这里我们要注意：
上溢是一种错误，使问题的处理无法进行;
而下溢一般认为是一种结束条件，即问题处理结束。

5.顺序栈的整表创建(含栈底，栈顶指针)

5.1顺序栈的结构定义：
typedef struct Sqstack
{
	SElemType* base;//栈底指针
	SElemType* top;//栈顶指针

	int stacksize;//栈可用的最大容量
}SqStack;
  • 在结构定义中，一个顺序栈里包含了栈底指针，栈顶指针，以及栈可用的最大容量这三个部分
  • 而别名SqStack用来定义顺序栈
    SqStack* 用来表示指向栈的指针
5.2顺序栈的初始化

注意：传入参数时，需传入栈的指针，即&s，这样才能修改栈中的数据

bool InitStack(SqStack* s)
5.2.1算法步骤：

(1)为顺序栈初始化空间，同时让栈底指针(base)指向被初始化的空间
(2)初始化栈顶指针 指向栈底位置
(3)初始化该顺序栈的最大容量

在这里插入图片描述

//2.顺序栈的初始化
//注意：传入参数时，需传入栈的指针，即&s，这样才能修改栈中的数据
bool InitStack(SqStack* s)
{
	//[1]为顺序栈初始化空间，同时让栈底指针指向被初始化的空间
	s->base = (SElemType *)malloc(sizeof(SElemType) * MAXSIZE);

	if (s->base == NULL)
	{
		printf("内存分配失败！\n");
		exit(-1);
	}

	//[2]初始化栈顶指针 指向栈底位置
	s->top = s->base;

	//[3]初始化该顺序栈的最大容量
	s->stacksize = MAXSIZE;
	return true;
}
5.3判断顺序栈是否为空

注意：传入参数时，不需要传入栈的指针，即&s，因为判空操作只需要访问栈顶指针与栈底指针，并不做修改

bool StackEmpty(SqStack s)
5.3.1算法步骤：

（1）若栈顶指针与栈底指针相同，说明栈空；否则栈非空，

在这里插入图片描述

//3.判断顺序栈是否为空
//注意：传入参数时，不需要传入栈的指针，即&s，因为判空操作只需要访问栈顶指针与栈底指针，并不做修改
bool StackEmpty(SqStack s)
{

	//[1]若栈顶指针与栈底指针相同，说明栈空
	if (s.top == s.base)
	{
		return true;
	}
	else
	{
		return false;
	}
}
5.4求顺序栈的长度

注意：传入参数时，不需要传入栈的指针，即&s，因为求长度只需要计算栈顶指针与栈底指针之差，并不做修改

int StackLength(SqStack s)
5.4.1算法步骤：

（1）栈顶指针 与 栈底指针的 差值即为顺序栈的长度

这里直接使用指针的差值，不需要"/sizeof(SqElemType)";因为两个指针的基类型为同一类型，其相减结果即为顺序栈的长度
在这里插入图片描述

//4.求顺序栈的长度
//注意：传入参数时，不需要传入栈的指针，即&s，因为求长度只需要计算栈顶指针与栈底指针之差，并不做修改
int StackLength(SqStack s)
{
	//栈顶指针 与 栈底指针的 差值即为顺序栈的长度
	return s.top - s.base;
}
5.5清空顺序栈

注意：传入参数时，需要传入栈的指针，即&s，因为清空栈需要修改栈顶指针，即s.top

bool ClearStack(SqStack * s)
5.5.1算法步骤：

（1）判断栈内存是否分配（通过判断栈底指针是否为空来实现）
（2）修改栈顶指针指向栈底位置即为清空(由于进栈时值会覆盖，故不需要删除元素值)

在这里插入图片描述
在这里插入图片描述

//5.清空顺序栈
//注意：传入参数时，需要传入栈的指针，即&s，因为清空栈需要修改栈顶指针，即s.top
bool ClearStack(SqStack * s)
{
	//[1]判断栈内存是否分配
	if (s->base == NULL)
	{
		printf("栈不存在！\n");
		return false;
	}

	//[2]修改 栈顶指针 指向 栈底位置，即为清空
	//(由于进栈时值会覆盖，故不需要删除元素值)
	s->top = s->base;
	return true;
}
5.6销毁顺序栈

注意：传入参数时，需要传入栈的指针，即&s，因为销毁栈需要修改清空内存，并置空栈中指针以及栈大小

bool DestroyStack(SqStack *s)
5.6.1算法步骤：

（1）若当前顺序栈存在，则先释放内存，再置空栈大小以及栈指针
<1>通过栈底指针释放内存
<2>置空栈大小以及栈指针(防止悬挂指针问题)

最终栈里除了stacksize，base和top被置空以外，其余部分均被销毁

//6.销毁顺序栈
//注意：传入参数时，需要传入栈的指针，即&s，因为销毁栈需要修改清空内存，并置空栈中指针以及栈大小
bool DestroyStack(SqStack *s)
{
	//[1]若当前顺序栈存在，则先释放内存，再置空栈大小以及栈指针
	if (s->base != NULL)
	{
		//<1>通过栈底指针释放内存
		free(s->base);
		
		//<2>置空栈大小以及栈指针
		s->stacksize = 0;

		s->base = NULL;
		s->top = NULL;
	}
	return true;
}
5.7顺序栈的入栈（核心1）

注意：传入参数时，需要传入栈的指针，即&s，因为入栈操作需要 更改栈顶指针以及 添加栈顶元素

bool Push(SqStack* s, SElemType e)
5.7.1算法步骤：

（1）判断栈是否已满（即 栈顶指针 与 栈底指针 之差 是否等于 栈的最大容量）
（2）入栈操作：
<1>先将元素e赋值给栈顶指针当前指向的位置
<2>然后栈顶指针自增1，指向当前 栈顶元素的 下一个位置
入栈操作可以浓缩为一步：
*s->top++ = e;

在这里插入图片描述

//7.核心1：顺序栈的入栈
//注意：传入参数时，需要传入栈的指针，即&s，因为入栈操作需要 更改栈顶指针以及 添加栈顶元素
bool Push(SqStack* s, SElemType e)
{
	//[1]判断栈是否已满（即 栈顶指针 与 栈底指针 之差 是否等于 栈的最大容量）
	if (s->top - s->base == s->stacksize)
	{
		printf("栈满！\n");
		return false;
	}

	//[2]入栈操作：
	//<1>先将元素e赋值给栈顶指针当前指向的位置
	*(s->top) = e;
	
	//<2>然后栈顶指针自增1，指向当前 栈顶元素的 下一个位置
	(s->top)++;
	//等价于 *s->top++ = e;先赋值，再向下移动

	return true;

}
5.8顺序栈的出栈（核心2）

注意：传入参数时，需要传入栈的指针，即&s，因为出栈操作需要 更改栈顶指针以及 带出栈顶元素

bool Pop(SqStack* s, SElemType* e)
5.8.1算法步骤：

（1）判断是否栈空（即栈顶指针 是否与 栈底指针指向相同）
（2）出栈操作：
<1>先将栈顶指针自减1，让其指向当前栈顶元素
<2>再将当前栈顶指针指向的栈顶元素 赋值给e
出栈操作可以浓缩为一步：
*e= *(–s->top);

在这里插入图片描述

//8.核心2：顺序栈的出栈
//注意：传入参数时，需要传入栈的指针，即&s，因为出栈操作需要 更改栈顶指针以及 带出栈顶元素
bool Pop(SqStack* s, SElemType* e)
{
	//[1]判断是否栈空（即栈顶指针 是否与 栈底指针指向相同）
	if (s->base == s->top)
	{
		printf("栈空！\n");
		return false;
	}

	//[2]出栈操作：
	//<1>先将栈顶指针自减1，让其指向当前栈顶元素
	--s->top;

	//<2>再将当前栈顶指针指向的栈顶元素 赋值给e
	*e = *(s->top);
	//等价于：*e=*(--s->top);先向底部移动栈顶指针，再取出栈顶元素
	return true;
}
5.9取栈顶元素

注意：传入参数时，不需要传入栈的指针，即&s，因为只取元素，不修改栈的数据

bool GetTop(SqStack s, SElemType* e)
5.9.1算法步骤：

（1）判断栈是否为空
（2）获取栈顶元素（注意是s.top - 1处的元素）

//9.取栈顶元素
//注意：传入参数时，不需要传入栈的指针，即&s，因为只取元素，不修改栈的数据
bool GetTop(SqStack s, SElemType* e)
{
	//[1]判断栈是否为空
	if (s.base == s.top)
	{
		printf("栈空！\n");
		return false;
	}

	//[2]获取栈顶元素：
	*e = *(s.top - 1);
	return true;
}
5.10输出顺序栈中的所有元素(从顺序栈顶开始输出)
bool printStack(SqStack s)
5.10.1算法步骤：

（1）判断该顺序栈是否为空
（2）定义临时指针指向当前栈顶元素（s.top - 1处的元素）
（3）p从栈顶开始，向栈底移动并依次输出栈中的元素

//10.输出顺序栈中的所有元素(从顺序栈顶开始输出)
bool printStack(SqStack s)
{
	//[1]判断该顺序栈是否为空
	if (s.base == s.top)
	{
		printf("顺序栈为空！\n");
		return false;
	}

	//[2]定义临时指针指向当前栈顶元素
	SElemType* p = s.top - 1;

	//[3]p从栈顶开始，向栈底移动并依次输出栈中的元素
	while (p>=s.base)
	{
		printf("%d-->", *(p));
		p--;
	}

	printf("end\n");
	return true;
}

21.所有操作如下：

//顺序栈的基本操作与实现（1.为了操作方便，栈顶指针指向栈顶元素的下一位置）
                     //(2.直接使用指针来定义栈顶，栈底指针)
#include<stdio.h>
#include<stdlib.h>


#define bool int
#define true 1
#define false 0

typedef int SElemType;//栈中数据元素的类型定义     


#define MAXSIZE 100//顺序栈的最大容量


//1.顺序栈的结构(这里直接使用指针来  定义栈顶指针  与  栈底指针)
//实际上也可以使用int类型的角标来模拟栈顶，栈底指针
typedef struct Sqstack
{
	SElemType* base;//栈底指针
	SElemType* top;//栈顶指针

	int stacksize;//栈可用的最大容量
}SqStack;


//2.顺序栈的初始化
//注意：传入参数时，需传入栈的指针，即&s，这样才能修改栈中的数据
bool InitStack(SqStack* s)
{
	//[1]为顺序栈初始化空间，同时让栈底指针指向被初始化的空间
	s->base = (SElemType *)malloc(sizeof(SElemType) * MAXSIZE);

	if (s->base == NULL)
	{
		printf("内存分配失败！\n");
		exit(-1);
	}

	//[2]初始化栈顶指针 指向栈底位置
	s->top = s->base;

	//[3]初始化该顺序栈的最大容量
	s->stacksize = MAXSIZE;
	return true;
}

//3.判断顺序栈是否为空
//注意：传入参数时，不需要传入栈的指针，即&s，因为判空操作只需要访问栈顶指针与栈底指针，并不做修改
bool StackEmpty(SqStack s)
{

	//[1]若栈顶指针与栈底指针相同，说明栈空
	if (s.top == s.base)
	{
		return true;
	}
	else
	{
		return false;
	}
}


//4.求顺序栈的长度
//注意：传入参数时，不需要传入栈的指针，即&s，因为求长度只需要计算栈顶指针与栈底指针之差，并不做修改
int StackLength(SqStack s)
{
	//栈顶指针 与 栈底指针的 差值即为顺序栈的长度
	return s.top - s.base;
}


//5.清空顺序栈
//注意：传入参数时，需要传入栈的指针，即&s，因为清空栈需要修改栈顶指针，即s.top
bool ClearStack(SqStack * s)
{
	//[1]判断栈内存是否分配
	if (s->base == NULL)
	{
		printf("栈不存在！\n");
		return false;
	}

	//[2]修改 栈顶指针 指向 栈底位置，即为清空
	//(由于进栈时值会覆盖，故不需要删除元素值)
	s->top = s->base;
	return true;
}

//6.销毁顺序栈
//注意：传入参数时，需要传入栈的指针，即&s，因为销毁栈需要修改清空内存，并置空栈中指针以及栈大小
bool DestroyStack(SqStack *s)
{
	//[1]若当前顺序栈不为空，则先释放内存，再置空栈大小以及栈指针
	if (s->base != NULL)
	{
		//<1>通过栈底指针释放内存
		free(s->base);
		
		//<2>置空栈大小以及栈指针
		s->stacksize = 0;

		s->base = NULL;
		s->top = NULL;
	}
	return true;
}


//7.核心1：顺序栈的入栈
//注意：传入参数时，需要传入栈的指针，即&s，因为入栈操作需要 更改栈顶指针以及 添加栈顶元素
bool Push(SqStack* s, SElemType e)
{
	//[1]判断栈是否已满（即 栈顶指针 与 栈底指针 之差 是否等于 栈的最大容量）
	if (s->top - s->base == s->stacksize)
	{
		printf("栈满！\n");
		return false;
	}

	//[2]入栈操作：
	//<1>先将元素e赋值给栈顶指针当前指向的位置
	*(s->top) = e;
	
	//<2>然后栈顶指针自增1，指向当前 栈顶元素的 下一个位置
	(s->top)++;
	//等价于 *s->top++ = e;先赋值，再向下移动

	return true;

}

//8.核心2：顺序栈的出栈
//注意：传入参数时，需要传入栈的指针，即&s，因为出栈操作需要 更改栈顶指针以及 带出栈顶元素
bool Pop(SqStack* s, SElemType* e)
{
	//[1]判断是否栈空（即栈顶指针 是否与 栈底指针指向相同）
	if (s->base == s->top)
	{
		printf("栈空！\n");
		return false;
	}

	//[2]出栈操作：
	//<1>先将栈顶指针自减1，让其指向当前栈顶元素
	--s->top;

	
	//<2>再将当前栈顶指针指向的栈顶元素 赋值给e
	*e = *(s->top);
	//等价于：*e=*(--s->top);先向底部移动栈顶指针，再取出栈顶元素
	return true;
}


//9.取栈顶元素
//注意：传入参数时，不需要传入栈的指针，即&s，因为只取元素，不修改栈的数据
bool GetTop(SqStack s, SElemType* e)
{
	//[1]判断栈是否为空
	if (s.base == s.top)
	{
		printf("栈空！\n");
		return false;
	}

	//[2]获取栈顶元素：
	*e = *(s.top - 1);
	return true;
}




//10.输出顺序栈中的所有元素(从顺序栈顶开始输出)
bool printStack(SqStack s)
{
	//[1]判断该顺序栈是否为空
	if (s.base == s.top)
	{
		printf("顺序栈为空！\n");
		return false;
	}

	//定义临时指针指向当前栈顶元素
	SElemType* p = s.top - 1;

	//p从栈顶开始，向栈底移动并依次输出栈中的元素
	while (p>=s.base)
	{
		printf("%d-->", *(p));
		p--;
	}

	printf("end\n");
	return true;
}



int main()
{
	SqStack s1;
	InitStack(&s1);  // 初始化栈

	// 入栈
	Push(&s1, 10);  
	Push(&s1, 20);
	Push(&s1, 30);
	Push(&s1, 31);
	Push(&s1, 32);

	printf("当前栈的长度: %d\n", StackLength(s1));
	printf("\n");

	// 获取栈顶元素
	SElemType ee;
	GetTop(s1, &ee);
	printf("当前栈顶元素为：%d\n", ee);

	printf("\n");
	printf("从当前栈顶元素向下输出：\n");
	printStack(s1);

	// 出栈
	printf("\n");
	SElemType e[10];
	for (int i = 0; i < 3; i++)
	{
		Pop(&s1, &e[i]);
		printf("出栈元素: %d\n", e[i]);
	}

	printf("\n");
	printf("从当前栈顶元素向下输出：\n");
	printStack(s1);

	// 清空栈
	ClearStack(&s1); 
	
	printf("栈是否为空: \n");
	if (StackEmpty(s1))
	{
		printf("栈为空！\n");
	}

	// 销毁栈
	if (DestroyStack(&s1))
	{
		printf("销毁成功！\n");
	}

	return 0;
}

在这里插入图片描述

float_com
关注
  • 22
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现 顺序栈（top指针刚开始指向-1
leonard10的博客
09-18 480
最一般类型的顺序栈
01. 顺序栈（S.top == -1）的具体实现
xxxxxueer的博客
04-18 922
编译软件：VS2019。
关于栈顶指针初值为-1和0的区别
weixin_46475770的博客
02-25 1万+
关于栈顶指针初值为-1或者0 的区别(c语言) 栈顶指针：S.top 栈顶元素：S.data[S.top] 当栈顶指针的初始值设置 S.top=-1时 ps: 当栈为空时，栈顶指针指向data[-1],但栈底是data[0] top data{4} data{3} data{2} data{1} data{0} data{-1} … 进栈操作：栈不满时，栈顶指针先+1，在送值到栈顶元素 （通俗来讲：先给客人指路，客人才知道自己的座位在哪） S.top=S.
【数据结构】-顺序栈(初始化栈顶指针为0）
RunningSnail的博客
07-23 5438
顺序栈-初始化栈顶指针为01.头文件及类型定义2.顺序栈类型定义3.函数声明4.基本操作4.1 初始化顺序栈4.2 判空4.3 入栈4.4 出栈4.5 读取栈顶元素4.6 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #define MaxSize 10 #define ElemType int //定义顺序栈中元素的最大个数 using namespace std; 2.顺序栈类型定义 typedef struct { ElemType data[
顺序栈栈顶指针指向详析
热门推荐
qq_45818316的博客
03-25 1万+
顺序栈栈顶指针指向详析 1.变长型（动态分配内存空间） #define STACK_INIT_SIZE 100 //存储空间初始分配量 #define STACKINCREMENT 10 // 存储空间分配增量 typedef struct{ SElemType *top; //定义栈顶指针top SElemType *base; //定义栈底指针base int stacksi...
栈的动态分配顺序存储的基本操作（top为指针且指针指向栈顶元素）
苍之羽
01-18 1万+
一、栈的动态分配顺序存储的结构定义： #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #include&amp;lt;assert.h&amp;gt; #define ERROR 0 #define OK 1 #define INIT_SIZE 10 /*栈的初始分配容量*/ #define INCREMENT 2 /*栈的
java栈实现--顺序栈
初心不忘、始终方得
04-22 3798
使用顺序存储结构实现的栈被称为顺序栈，这篇文章总结如何实现顺序栈
【栈】顺序栈知识点-内含基本操作及其说明
qq_53830608的博客
01-15 1358
函数的设计：bool来判断返回值是否为空，想要把数据带回必须用到指针。判满函数属于内部函数，因为外部函数一般都是动态创建内存，不需要判满。判满条件：数据个数（即当前栈顶位置-栈底0）与容量相等时，栈满。栈空：ps->base==NULL;入栈、出栈、获取栈顶元素、销毁、判空。入栈操作：元素赋值到栈顶，栈顶++栈内总容量为INITSIZE。先判满，如果栈满，扩容。realloc:扩容。
【数据结构】顺序栈和链栈--Stack
Z1tai的博客
11-11 1763
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
shujujiegou.rar_shujujiegou-erchashu_二叉树 建立 遍历_栈
09-19
每个节点包含一个数据域用于存储元素，以及两个指针域，分别指向左子节点和右子节点。在构建过程中，我们通常从根节点开始，递归地处理左右子树，直至所有节点都被添加到链表中。 栈是一种具有“后进先出”（LIFO）...
(完整word版)广东工业大学-数据结构试卷.doc
12-14
1. 顺序存储的线性表删除元素的平均移动次数是(n-1)/2，n是表的长度。 2. 栈的两端分别被称为栈顶（插入和删除的一端）和栈底。 3. 模式串P=’ababc’的next函数值序列是0,1,1,2,1。 4. 深度为6的完全二叉树的节点数...
链表-使用Python基于链表实现数组栈.zip
03-13
这种方法尤其适用于需要频繁进行压栈和弹栈操作，但对元素访问顺序不敏感的情况。 总结起来，这个压缩包文件提供了关于链表和数组栈的知识点，包括链表的基本概念、Python中如何模拟链表、数组栈的LIFO原理以及如何...
栈的应用 -- 括号匹配1
08-08
首先，我们看到代码定义了一个顺序栈（sequence_stack）的数据结构，它包含一个整型数组a和一个表示栈顶指针的变量top。栈的初始化函数`init()`用于将栈顶指针设置为0，表示栈为空。判断栈是否为空的函数`empty()`...
数据结构-栈的应用：顺序栈与链栈的应用
03-22
- **定义**：链栈是通过链表实现的栈，每个节点包含一个数据元素和指向下一个节点的指针。栈顶元素就是链表的头节点。 - **优点**：动态扩展，不会出现溢出问题，适用于数据规模变化较大的情况。 - **缺点**：...
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 500
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
二叉树详解（1）
weixin_73077334的博客
08-15 1268
二叉树详解（1）
数据结构之排序（下）
qq_74336191的博客
08-15 665
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
【数据结构】二叉树篇
2303_79015671的博客
08-14 1344
深入解析数据结构二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值