【数据结构】栈 （顺序栈+链栈）

已于 2022-04-05 22:48:41 修改
阅读量262 收藏 2
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
于 2022-04-03 14:30:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56499830/article/details/123905658
版权

文章目录

一、栈的概念

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。
栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。栈也称为先进后出表。

生活中栈的相似例子：

  • 向橱柜里放取盘子（往最上面放，从最上面取）
  • 子弹弹夹

栈的图示：
在这里插入图片描述
在这里插入图片描述

二、顺序栈

  • 一个数组（可扩容） 接受malloc从堆内申请来的连续内存块
  • top（int） 栈顶指针 既保存有效值个数，也可以理解为保存下一个元素插入位置
  • stack_size 当前空间的总大小，帮助我们扩容用的

顺序栈的头文件与函数声明

#pragma once

//顺序栈的结构体声明


#define INIT_SIZE 10
typedef int ELEM_TYPE;

typedef struct Stack
{
	ELEM_TYPE * base;//保存从堆内申请的一整块连续内存
	int top;//栈顶指针  和书上有些区别，书上这里用的是指针类型
	int stack_size;//保存栈当前可使用的最大容量
}Stack, *PStack;


//对应的栈的相关可执行函数声明：

//初始化
void Init_Stack(struct Stack* ps);

//入栈
bool Push(PStack ps, ELEM_TYPE val);

//出栈 (1.不仅需要告诉我出栈是否成功，2.还需要告诉我出栈的值是多少(借助输出参数))
bool Pop(PStack ps, ELEM_TYPE* rtval);

//获取栈顶元素(1.不仅需要告诉我此操作是否成功，2.还需要告诉我栈顶元素的值是多少(借助输出参数)
bool Top(PStack ps, ELEM_TYPE *rtval);

//获取有效值个数
int Get_length(PStack ps);

//查找
int Search(PStack ps, ELEM_TYPE val);

//打印
void Show(PStack ps);

//判空
bool IsEmpty(PStack ps);

//判满
bool IsFull(PStack ps);

//扩容  // 扩容倍数 *2
void Inc(PStack ps);

//清空
void Clear(PStack ps);

//销毁
void Destroy(PStack ps);

1.初始化顺序栈

从堆区申请一块连续空间，初始化 stack_size ,将栈顶置为0
代码如下：

//初始化
void Init_Stack(struct Stack* ps)
{
	//assert
	ps->base = (ELEM_TYPE *)malloc(INIT_SIZE * sizeof(struct Stack));
	assert(ps->base != NULL);
	if(ps->base == NULL)
	{
		return;
	}
	ps->top = 0;
	ps->stack_size = INIT_SIZE;
}

2.获取有效值个数

直接返回栈顶的值就是栈的有效值个数
代码如下：

//获取有效值个数
int Get_length(PStack ps)
{
	//assert
	return ps->top;
}

3.判空与判满

3.1判空

如果栈顶指针的值为0的话，就说明他是一个空栈，返回true，否则返回false

//判空
bool IsEmpty(PStack ps)
{
	return ps->top == 0;
}

3.2判满

当栈顶指针的值等于 stack_size是说明栈已满

//判满
bool IsFull(PStack ps)
{
	//assert ps
	return ps->top == ps->stack_size;
}

4.扩容

先判满，如果栈满的话，开始扩容

使用realloc函数，重新分配内存大小
扩容方式：

先看原空间后面有没有足够的空间分配，有的话直接续上。
后面如果没有足够的空间，重新找一块足够大的内存，重新分配。将原有内存数据拷贝过来，然后释放掉。
后面连续闲置空间不够，且重新找一块也找不到，则realloc失败
​​​​
代码如下 ：

//扩容  // 扩容倍数 *2
void Inc(PStack ps)
{
	ps->base = (ELEM_TYPE *)realloc(ps->base, ps->stack_size*sizeof(Stack) * 2);
	assert(ps->base != NULL);

	ps->stack_size *= 2;
}

5.​入栈

通过栈顶指针直接找到栈顶然后插入，如果满栈的话，扩容

//入栈
bool Push(PStack ps, ELEM_TYPE val)
{
	//直接找到栈顶  进行插入（warning：一定记着插入结束后，让栈顶指针挪动一下）

	//assert  ps  不能满   满的话得扩容
	assert(ps != NULL);
	if(IsFull(ps))
	{
		Inc(ps);
	}

	//执行到这一块  肯定有格子让我们存放val    
	/*
	ps->base[ps->top] = val;
	ps->top++;
	*/
	ps->base[ps->top++] = val;

	return true;
}

6.出栈

1.不仅需要告诉我出栈是否成功
2.还需要告诉我出栈的值是多少(借助输出参数)

首先判空，不为空的话直接使栈顶指针-1 即可（不需要重置数据）

//出栈
bool Pop(PStack ps, ELEM_TYPE* rtval)
{
	//assert  ps   rtval
	if(IsEmpty(ps))
	{
		return false;
	}

	/*
	ps->top--;
	*rtval = ps->base[ps->top];
	*/
	*rtval = ps->base[--ps->top];

	return true;
}

7.获取栈顶元素

1.不仅需要告诉我此操作是否成功
2.还需要告诉我栈顶元素的值是多少(借助输出参数)

返回栈顶指针-1的值（不修改栈顶指针）

//获取栈顶元素
bool Top(PStack ps, ELEM_TYPE *rtval)
{
	//assert  ps   rtval
	if(IsEmpty(ps))
	{
		return false;
	}

	*rtval = ps->base[ps->top-1];

	return true;
}

8.查找

通过for循环遍历栈内元素，返回下标

//查找
int Search(PStack ps, ELEM_TYPE val)
{
	//assert

	for(int i=0; i<ps->top; i++)
	{
		if(ps->base[i] == val)
		{
			return i;
		}
	}

	return -1;
}

9.清空与销毁

9.1清空

malloc 申请来的格子不用释放 只需要将有效值个数重新赋值为0即可
也不需要修改数据

//清空
void Clear(PStack ps)
{
	ps->top = 0;//清空  == 只要认为里面的值都是无效值即可   不需要修改里面的值
}

9.2销毁

malloc 申请来的格子释放掉

void Destroy(PStack ps)
{
	free(ps->base);
	ps->base = NULL; //避免出现野指针  并且还可以防止重复释放导致出现崩溃

	ps->top = ps->stack_size = 0; //洗干净衣服  再扔掉
}

顺序栈源文件与函数实现

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include "stack.h"


//初始化
void Init_Stack(struct Stack* ps)
{
	//assert
	ps->base = (ELEM_TYPE *)malloc(INIT_SIZE * sizeof(struct Stack));
	assert(ps->base != NULL);
	if(ps->base == NULL)
	{
		return;
	}
	ps->top = 0;
	ps->stack_size = INIT_SIZE;
}

//入栈
bool Push(PStack ps, ELEM_TYPE val)
{
	//直接找到栈顶  进行插入（warning：一定记着插入结束后，让栈顶指针挪动一下）

	//assert  ps  不能满   满的话得扩容
	assert(ps != NULL);
	if(IsFull(ps))
	{
		Inc(ps);
	}

	//执行到这一块  肯定有格子让我们存放val    
	/*ps->base[ps->top] = val;
	ps->top++;*/
	ps->base[ps->top++] = val;

	return true;
}


//出栈 (1.不仅需要告诉我出栈是否成功，2.还需要告诉我出栈的值是多少(借助输出参数))
bool Pop(PStack ps, ELEM_TYPE* rtval)
{
	//assert  ps   rtval
	if(IsEmpty(ps))
	{
		return false;
	}

	/*ps->top--;
	*rtval = ps->base[ps->top];*/
	*rtval = ps->base[--ps->top];

	return true;
}


//获取栈顶元素(1.不仅需要告诉我此操作是否成功，2.还需要告诉我栈顶元素的值是多少(借助输出参数)
bool Top(PStack ps, ELEM_TYPE *rtval)
{
	//assert  ps   rtval
	if(IsEmpty(ps))
	{
		return false;
	}

	*rtval = ps->base[ps->top-1];

	return true;
}

//获取有效值个数
int Get_length(PStack ps)
{
	//assert
	return ps->top;
}

//查找
int Search(PStack ps, ELEM_TYPE val)
{
	//assert

	for(int i=0; i<ps->top; i++)
	{
		if(ps->base[i] == val)
		{
			return i;
		}
	}

	return -1;
}

//打印
void Show(PStack ps)
{
	//assert

	for(int i=0; i<ps->top; i++)
	{
		printf("%d ", ps->base[i]);
	}
	printf("\n");
}

//判空
bool IsEmpty(PStack ps)
{
	return ps->top == 0;
}

//判满
bool IsFull(PStack ps)
{
	//assert ps
	return ps->top == ps->stack_size;
}

//扩容  // 扩容倍数 *2
void Inc(PStack ps)
{
	ps->base = (ELEM_TYPE *)realloc(ps->base, ps->stack_size*sizeof(Stack) * 2);
	assert(ps->base != NULL);

	ps->stack_size *= 2;
}

//清空(malloc 申请来的格子不用释放    只需要将有效值个数重新赋值为0即可)
void Clear(PStack ps)
{
	ps->top = 0;//清空  == 只要认为里面的值都是无效值即可   不需要修改里面的值
}

//销毁（malloc 申请来的格子释放掉）
void Destroy(PStack ps)
{
	free(ps->base);
	ps->base = NULL; //避免出现野指针  并且还可以防止重复释放导致出现崩溃

	ps->top = ps->stack_size = 0; //洗干净衣服  再扔掉
}

三、链栈

例如：入栈 1 2 3 4 5
在这里插入图片描述
我们只需要在头部进行插入和删除就可以完美模拟栈的运行，还有一个好处（时间复杂度很低）
所以链栈的结构体设计只需要使用单链表的结构体设计即可

链栈的头文件及函数声明

#pragma once

typedef int ELEM_TYPE;
//链栈的结构体设计只需要使用单链表的结构体设计即可（用头插和头删来模拟入栈和出站）
typedef struct LStack
{
	ELEM_TYPE data;//数据域
	struct LStack * next;//指针域
}LStack, *PLStack;


//对应的栈的相关可执行函数声明：

//初始化
void Init_LStack(struct LStack* ps);

//入栈
bool Push(PLStack ps, ELEM_TYPE val);

//出栈 (1.不仅需要告诉我出栈是否成功，2.还需要告诉我出栈的值是多少(借助输出参数))
bool Pop(PLStack ps, ELEM_TYPE* rtval);

//获取栈顶元素(1.不仅需要告诉我此操作是否成功，2.还需要告诉我栈顶元素的值是多少(借助输出参数)
bool Top(PLStack ps, ELEM_TYPE *rtval);

//获取有效值个数
int Get_length(PLStack ps);

//查找
struct LStack* Search(PLStack ps, ELEM_TYPE val);

//打印
void Show(PLStack ps);

//判空
bool IsEmpty(PLStack ps);

//判满  (链式结构不需要判满)

//清空
void Clear(PLStack ps);

//销毁
void Destroy1(PLStack ps);
void Destroy2(PLStack ps);

1.初始化

初始化头节点

//初始化
void Init_LStack(struct LStack* ps)
{
	//assert
	//ps->data;//头结点的数据域不使用
	ps->next = NULL;
}

2.入栈

直接使用单链表头插法
首先通过 **malloc（）**函数申请一个节点，保存val值
然后把头节点指向的next的地址赋值给 s->next
在这里插入图片描述
最后 把s 的地址赋值给头节点的next域
在这里插入图片描述

//入栈(头插)
bool Push(PLStack ps, ELEM_TYPE val)
{
	//assert
	//购买新节点
	PLStack s = (struct LStack *)malloc(sizeof(struct LStack));
	assert(s != NULL);
	s->data = val;

	//头部插入
	s->next = ps->next;
	ps->next = s;

	return true;
}

3.出栈

单链表头删

  • 不仅需要告诉我出栈是否成功
  • 还需要告诉我出栈的值是多少(借助输出参数)

1.申请一个临时指针指向待删除节点
在这里插入图片描述
2.跨越指向，将待删除节点跨越过去，让p->next赋值给 ps->next
在这里插入图片描述

3.释放待删除节点
在这里插入图片描述
代码如下：

//出栈 （头删）
bool Pop(PLStack ps, ELEM_TYPE* rtval)
{
	//assert
	if(IsEmpty(ps))//是一个空栈的话
	{
		return false;
	}
	*rtval = ps->next->data;//将一会要出栈的值 通过rtval带出来

	//1.申请一个临时指针指向待删除节点
	struct LStack * p = ps->next; //因为上面判空过， 所以这里p还不为NULL

	//2.跨越指向，将待删除节点跨越过去
	ps->next = p->next;

	//3.释放待删除节点
	free(p);

	return true;
}

4.判空

如果 头指针的next域为NULL 的话，说明为空栈

bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

5.查找

通过遍历链表，找到链表内数据域与val值相同的节点，返回该节点的地址

//查找
struct LStack* Search(PLStack ps, ELEM_TYPE val)
{
	//assert
	for(LStack *p=ps->next; p!=NULL; p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

6.销毁

6.1第一种销毁方法

无限头删，直到头节点的next域为NULL 即为空栈

//销毁
void Destroy1(PLStack ps)
{
	//无限头删
	while(ps->next != NULL)
	{
		LStack * p = ps->next;
		ps->next = p->next;
		free(p);
	}

	ps->next = NULL;
}

6.2第二种销毁方式

提前踢出去头节点，借助两个临时指针
使p指向第一个节点，ps->next = NULL
在这里插入图片描述
当p！=NULL的时候 使q = p->next; 然后释放p
在这里插入图片描述
然后使 p = q
在这里插入图片描述
此时完成一次循环
再使 p = p->next; free（q）;
在这里插入图片描述
直到 p ==NULL 的时候结束循环；此时销毁完成

链栈的源文件与函数实现

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include "list_stack.h"

//对应的栈的相关可执行函数声明：

//初始化
void Init_LStack(struct LStack* ps)
{
	//assert
	//ps->data;//头结点的数据域不使用
	ps->next = NULL;
}

//入栈(头插)
bool Push(PLStack ps, ELEM_TYPE val)
{
	//assert
	//购买新节点
	PLStack s = (struct LStack *)malloc(sizeof(struct LStack));
	assert(s != NULL);
	s->data = val;

	//头部插入
	s->next = ps->next;
	ps->next = s;

	return true;
}

//出栈 （头删）(1.不仅需要告诉我出栈是否成功，2.还需要告诉我出栈的值是多少(借助输出参数))
bool Pop(PLStack ps, ELEM_TYPE* rtval)
{
	//assert
	if(IsEmpty(ps))//是一个空栈的话
	{
		return false;
	}
	*rtval = ps->next->data;//将一会要出栈的值 通过rtval带出来

	//1.申请一个临时指针指向待删除节点
	struct LStack * p = ps->next; //因为上面判空过， 所以这里p还不为NULL

	//2.跨越指向，将待删除节点跨越过去
	ps->next = p->next;

	//3.释放待删除节点
	free(p);

	return true;
}

//获取栈顶元素(1.不仅需要告诉我此操作是否成功，2.还需要告诉我栈顶元素的值是多少(借助输出参数)
bool Top(PLStack ps, ELEM_TYPE *rtval)
{
	//assert
	if(IsEmpty(ps))//是一个空栈的话
	{
		return false;
	}

	*rtval = ps->next->data;
	return true;
}

//获取有效值个数
int Get_length(PLStack ps)
{
	//用不需要前驱操作的for循环  
	int count = 0;//计数器  保存有效值个数
	for(LStack *p=ps->next; p!=NULL; p=p->next)
	{
		count++;
	}

	return count;
}

//查找
struct LStack* Search(PLStack ps, ELEM_TYPE val)
{
	//assert
	for(LStack *p=ps->next; p!=NULL; p=p->next)
	{
		if(p->data == val)
		{
			return p;
		}
	}

	return NULL;
}

//打印
void Show(PLStack ps)
{
	for(LStack *p=ps->next; p!=NULL; p=p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//判空
bool IsEmpty(PLStack ps)
{
	return ps->next == NULL;
}

//判满  (链式结构不需要判满)

//清空
void Clear(PLStack ps)
{
	Destroy1(ps);
}

//销毁
void Destroy1(PLStack ps)
{
	//无限头删
	while(ps->next != NULL)
	{
		LStack * p = ps->next;
		ps->next = p->next;
		free(p);
	}

	ps->next = NULL;
}

//不借助头结点，要用到两个临时指针
void Destroy2(PLStack ps)
{
	//assert    ps!=NULL
	PLStack p = ps->next;
	PLStack q = NULL;

	ps->next = NULL;//将头结点提前剔出去  

	while(p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}
顺序栈和链栈（stack）
IT_Quanwudi的博客
11-06 789
顺序栈和链栈（stack） 栈的定义：它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 我们把栈分为顺序栈和链栈两种，两者分别用不同方...
4.（数据结构）顺序栈+链栈+栈的应用(中缀转后缀表达式)
weixin_45386223的博客
10-14 529
堆栈：LIFO结构 1.按一定顺序进栈然后所有出栈顺序的可能性： 核心：出栈的第一个元素是在原来的次序中是第几个，那么比它先入栈的元素，出栈顺序必须是逆序 因为从小到大入栈顺序是确定的，而出栈是随机的，也就是在入栈还没结束的情况下就可以出栈。这样，就会出现一些小的数提前出栈的现象。但是那些“守规矩”的小数相对位置是没有变化的。比如入栈12345，结果在4入栈之前3不听话先出去了。但是这不会影响1和...
java实现栈的方法
weixin_42069523的博客
04-04 411
栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定...
数据结构——栈
最新发布
2302_80420838的博客
10-07 864
栈是一种线性表，它遵循，在插入删除时**只能在栈顶进行**。在程序设计中，如果按照保存数据的相反顺序来使用数据，就可以用栈实现。
java实现栈的数据结构
weixin_34235371的博客
07-21 115
栈是一种数据结构，只能从一端进行存储和访问。常规操作有压入栈和弹出栈。 特性：先进先出，LIFO 以下是用ArrayList为内核实现一个栈的数据结构  import java.util.ArrayList; import java.util.List; import java.util.EmptyStackException; public class Statck&lt;E e...
java实现栈_java数据结构之java实现栈
weixin_28894087的博客
02-15 115
import java.util.Arrays;/*** 栈的实现* @author Skip* @version 1.0*/public class Stack {private int size; //栈中元素的个数private Object[] arr;//底层数组private final int defaultLength = 200;//默认长度/*** 无参构造,使用默...
java实现栈-数据结构
CONSOLE___的博客
11-24 322
栈(stack) 1)栈是一个先入后出(FILO-First In Last Out)的有序列表 2)栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一段，成为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 3)根据栈的定义可知，最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 入栈(push)的图解： 出栈(pop) 栈的应用场景 1）子程序的调用：
停车场管理系统(C语言顺序栈+链栈+链队列)
04-20
本项目以C语言为基础，运用了顺序栈、临时栈链栈和排队车道链队列的数据结构，为实现停车场管理提供了高效而灵活的解决方案。 首先，让我们深入了解这些数据结构： 1. **顺序栈**：顺序栈是一种线性数据结构，它...
数据结构课程：顺序栈和链栈的实现
10-16
### 数据结构课程：顺序栈和链栈的实现 #### 栈的基本概念 栈是一种特殊的线性表，其特殊之处在于所有元素的插入和删除都只能在一端进行，这一端被称为栈顶(top)，与之相对的一端称为栈底(bottom)。栈通常支持以下...
数据结构顺序栈链栈.pdf
09-30
数据结构顺序栈链栈 根据提供的文件信息，我们可以总结出以下知识点： 1. 顺序栈的定义和实现： 顺序栈是一种数据结构，它使用数组来存储元素。顺序栈的实现需要定义栈的结构体，包括元素数组和栈顶指针。顺序栈...
数据结构-栈的应用：顺序栈与链栈的应用
03-22
在这个主题中，我们将专注于栈（Stack）这一特殊的数据结构，及其在实际应用中的两种主要实现方式：顺序栈（Sequential Stack）和链栈（Linked Stack）。栈通常被称为“后进先出”（LIFO，Last In First Out）的数据...
Java实现栈数据结构
weixin_33686714的博客
02-15 128
栈（英语：stack）又称为栈或堆叠，是计算机科学中一种特殊的串列形式的抽象数据类型，其特殊之处在于只能允许在链表或数组的一端（称为堆栈顶端指针，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。另外栈也可以用一维数组或链表的形式来完成。堆栈的另外一个相对的操作方式称为队列。 由于堆栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In Firs...
Java实现栈操作
FiveStarsGeneral的博客
05-12 341
栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。（百度百科） 如图： 其中，把数据写入称为入栈或压栈（push），把数据写出称为出栈（pop）。 当栈为空，此时，栈顶=栈底 Java实现 package Stack; //先进后出 p
Java实现栈结构
m0_62404808的博客
01-05 1541
栈（Stack）也是数据结构的一种，属于线性数据结构，栈最大的特点是“先进后出”，就是先进入栈的元素后出来，栈只能每次弹出栈顶元素，不能弹出处在栈中间的元素。
Java数据结构-栈的实现
qq_39303325的博客
11-12 241
Java数据结构-栈的实现Java数据结构（一）栈的介绍栈的ADT接口实例应用笔记 Java数据结构（一） 数据结构学习笔记。 栈的介绍 在许多算法设计中都需要一种"先进后出(First Input Last Output)"的数据结构，因而一种被称为"栈"的数据结构被抽象了出来。 栈的结构类似一个罐头：只有一个开口；先被放进去的东西沉在底下，后放进去的东西被放在顶部；想拿东西必须按照从上到下的顺序进行操作。 　　 栈的ADT接口 /** * 栈ADT 接口定义 * */ public int
java 堆和栈 数据结构_java实现堆栈数据结构和操作
weixin_42372731的博客
02-27 326
代码如下：public static void main(String[] args) { Stack stack = new Stack(5); stack.push(1); stack.push(4); stack.push(3); stack.push(2); stack.push(5); ...
C语言实现：顺序栈与链栈操作详解
"数据结构课程涵盖了顺序栈和链栈的实现，主要使用C语言进行编程。顺序栈是基于一组连续存储单元实现的栈，而链栈则是通过链式存储结构来实现。这两种栈都支持常见栈操作，如初始化、入栈、出栈、取顶、查询栈长和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Shang_Jianyu_ss

感谢大哥

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

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

打赏作者

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

抵扣说明：

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

余额充值