数据结构顺序栈基本操作（C/C++实现）

千次阅读 多人点赞

2019-10-26 02:38:53

数据结构顺序栈基本操作（C/C++实现）

注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据

涉及基本运算流程

1.初始化栈

2.判断栈是否非空

3.元素依次进栈

4.判断栈是否非空

5.输出出栈序列

6.判断栈s是否非空

7.释放栈

GitHub地址（包含.cpp文件和可执行程序exe）

我的数据结构GitHub地址

源代码（经VS2015、devC++编译器运行通过）

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;
typedef char SElemType; /* SElemType类型根据实际情况而定，这里假设为char */

					   /* 顺序栈结构 */
typedef struct
{
	SElemType data[MAXSIZE];
	int top; /* 用于栈顶指针 */
}SqStack;

Status visit(SElemType c)
{
	printf("%d ", c);
	return OK;
}

/*  构造一个空栈S */
Status InitStack(SqStack *S)
{
	/* S.data=(SElemType *)malloc(MAXSIZE*sizeof(SElemType)); */
	S->top = -1;
	return OK;
}

/* 把S置为空栈 */
Status ClearStack(SqStack *S)
{
	S->top = -1;
	return OK;
}

/* 若栈S为空栈，则返回TRUE，否则返回FALSE */
Status StackEmpty(SqStack S)
{
	if (S.top == -1)
		return TRUE;
	else
		return FALSE;
}

/* 返回S的元素个数，即栈的长度 */
int StackLength(SqStack S)
{
	return S.top + 1;
}

/* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
Status GetTop(SqStack S, SElemType *e)
{
	if (S.top == -1)
		return ERROR;
	else
		*e = S.data[S.top];
	return OK;
}

/* 插入元素e为新的栈顶元素 */
Status Push(SqStack *S, SElemType e)
{
	if (S->top == MAXSIZE - 1) /* 栈满 */
	{
		return ERROR;
	}
	S->top++;				/* 栈顶指针增加一 */
	S->data[S->top] = e;  /* 将新插入元素赋值给栈顶空间 */
	return OK;
}

/* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
Status Pop(SqStack *S, SElemType *e)
{
	if (S->top == -1)
		return ERROR;
	*e = S->data[S->top];	/* 将要删除的栈顶元素赋值给e */
	S->top--;				/* 栈顶指针减一 */
	return OK;
}

/* 从栈底到栈顶依次对栈中每个元素显示 */
Status StackTraverse(SqStack S)
{
	int i;
	i = 0;
	while (i <= S.top)
	{
		visit(S.data[i++]);
	}
	printf("\n");
	return OK;
}

int main()
{
	int j;
	SqStack s;
	int e;
	/*1.初始化栈*/
	InitStack(&s); 
	printf("初始化栈成功\n"); 

	/*2.判断栈s是否非空*/
	printf("2.栈空否：%d(1:空 0:否)\n", StackEmpty(s));
	
	/*3.依次进栈abcde*/
		Push(&s, 'a');
		Push(&s, 'b');
		Push(&s, 'c');
		Push(&s, 'd');
		Push(&s, 'e');
		printf("3.abcde依次进栈完毕\n");

	/*4.判断栈s是否非空*/
		printf("2.栈空否：%d(1:空 0:否)\n", StackEmpty(s));

	/*5.输出出栈序列*/
		printf("4.栈中元素依次为：");
			StackTraverse(s);

	/*6.判断栈s是否非空*/
		printf("5.栈空否：%d(1:空 0:否)\n", StackEmpty(s));

	/*7.释放栈*/
		ClearStack(&s);
		printf("6.栈释放完毕，");
		printf("释放栈后，栈空否：%d(1:空 0:否)\n", StackEmpty(s));
	/*Pop(&s, &e);
	printf("弹出的栈顶元素 e=%d\n", e);
	printf("栈空否：%d(1:空 0:否)\n", StackEmpty(s));
	//GetTop(s, &e);
	printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(s));
	ClearStack(&s);
	printf("清空栈后，栈空否：%d(1:空 0:否)\n", StackEmpty(s));
	*/
	system("pause"); 
	return 0;
}

数据结构 C/C++

更多相关内容

顺序栈基本操作
2017-03-04 16:03:26

数据结构顺序栈基本操作

收起
顺序栈基本操作.cpp
2019-11-21 10:30:11

初学数据结构，不是很熟悉，大家一起共同学习，多交流一下，顺序栈基本操作，如有错误请大家多多指教，我会及时更正

收起
顺序栈的基本操作实现
2020-11-16 14:11:20

顺序栈的基本操作实现实验要求：（1）建立含有若干个元素的顺序栈；（2）对已建立的顺序栈实现判空、进栈、出栈、取栈顶元素等基本操作；（3）在主函数中调用栈的基本操作函数实现输入序列的反转。

收起

数据结构

顺序栈基本操作代码实现

千次阅读 2020-12-28 10:15:44

顺序栈基本操作代码实现 /***顺序栈的实现***/ #include<iostream> using namespace std; #include<stdlib.h> #include<cstdlib> //顺序栈定义 #define OK 0 #define ERROR -1 #define OVERFLOW...

顺序栈基本操作代码实现

#include<iostream>
using namespace std;
#include<stdlib.h>
#include<cstdlib> 

//顺序栈定义
#define OK 0
#define ERROR -1
#define OVERFLOW -2
#define MAXSIZE  100
typedef int Status;
typedef int SElemType;
typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

//算法1　顺序栈的初始化
Status InitStack(SqStack &S)
{// 构造一个空栈 S 
	S.base=new int[MAXSIZE];
	if(!S.base) 
	{
		cout<<"初始化失败"<<endl;
		return ERROR;
	}
	else
	{
		cout<<"初始化成功"<<endl;
		S.top=S.base;
		S.stacksize=0;
		return OK;	
	}
	
}
//算法2　顺序栈的入栈
Status Push(SqStack &S,SElemType e)
{ // 插入元素e为新的栈顶元素
	if(S.top-S.base==MAXSIZE)
		return ERROR;
	*S.top++=e;
	return OK;
}
//算法3　顺序栈的出栈
Status Pop(SqStack &S,SElemType &e)
{// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
	if(S.top==S.base)
		return ERROR;
	e=*--S.top;
	return OK;
}
//算法4　取顺序栈的栈顶元素
Status GetTop(SqStack S,SElemType &e)
{// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
	if(S.top==S.base)
	  return ERROR;
	e=*S.top;
	return OK;
}
//算法5  判断栈是否为空
//若栈为空，输出栈为空 返回ERROR，不为空，输出不为空，返回OK 
Status StackEmpty(SqStack &S)
{
    if (S.top == S.base)
        return OK;  	
    else
        return ERROR;
}
//算法6  取栈顶元素
Status GetTop(SqStack &S)
{
	if(S.top==S.base)
	{//若栈为空，返回ERROR，并且输出栈为空，无栈顶元素
		cout<<"栈为空,无栈顶元素"<<endl;
		return ERROR;
	}
	else
	{//若栈不为空，返回OK，并且输出栈顶元素 
		cout<<"栈顶元素为"<<*(S.top)<<endl;
		return OK;	
	}
}

//算法7 清空栈 
Status ClearStack(SqStack &S)
{
	S.top=S.base;
	cout<<"栈已清空"<<endl;
	return OK;	
} 

//算法8  销毁栈 
Status DestoryStack(SqStack &S)
{
	delete(S.base);
	S.base=NULL;
	S.top=NULL;
	S.stacksize=0;
	cout<<"栈已销毁"<<endl;
	return OK;
}

//算法9  输出栈中所有元素，弹出所有元素 
Status OutputStack(SqStack S)
{
	cout<<"栈中全部元素为:";
	for(int i=0;i<S.stacksize;i++)
	{
		int m;
		Pop(S,m);
		cout<<m<<" ";
	}
	cout<<endl;
	return 0;
}
Status main()
{
	SqStack S;
	int choose=-1;
	cout<<"1.初始化栈"<<endl;
	cout<<"2.销毁栈"<<endl;
	cout<<"3.清空栈"<<endl;
	cout<<"4.栈判空"<<endl;
	cout<<"5.求栈长度"<<endl;
	cout<<"6.获取栈顶元素"<<endl;	
	cout<<"7.插入一个元素"<<endl;
	cout<<"8.删除一个元素"<<endl;
	cout<<"9.输出所有元素"<<endl;
	cout<<"10.进制转换"<<endl;
	cout<<"0.退出"<<endl;
	while(choose!=0)
	{
		cout<<"请输入选择的功能"<<endl;
		cin>>choose;
		switch(choose)
		{
			case 1:
				InitStack(S);                               //1.初始化栈
			break;
			case 2:
				DestoryStack(S);                            //2.销毁栈 
			break;
			case 3:
				ClearStack(S);                               //3.清空栈元素 
			break;
			case 4:
				StackEmpty(S);                               //4.栈判空
			break;
			case 5:
				cout<<"栈长度为"<<S.stacksize<<endl;         //5.求栈长度 
			break;
			case 6:
				GetTop(S);                                   //6.求栈顶元素 
			break;
			case 7:
				cout<<"请输入进栈元素："<<endl;              //7.插入一个元素，进栈 
				SElemType e;
				cin>>e;
				S.stacksize++; 
				Push(S,e);
			break;
			case 8:                                                  //8.删除一个元素，出栈 
				cout<<endl<<"弹出的栈顶元素为："<<endl;
				SElemType t;
				Pop(S,t);
				cout<<t<<" "<<endl;
			break;
			case 9:
				OutputStack(S);                                     //9.输出栈的所有元素 
			break;
			case 10:                                                //10.进制转换
				int N,d;
			    SqStack S1;
			    InitStack(S1);
			    cout<<"请输入要转换的数:"<<endl;
			    cin>>N;
			    cout<<"请输入要转换的进制:"<<endl;
			    cin>>d;
			    while(N)
			    {
			        Push(S1,N%d);
			        N=N/d;
			    }
			    cout<<"转换后的数为：";
			    while(StackEmpty(S1))
			    {
			        int e;
			        Pop(S1,e);
			        cout<<e;
			    }
			    cout<<endl;
			break;
			case 0:	
			break;	
		} 
	}
	return 0;
}

收起

展开全文

数据结构

顺序栈基本操作的实现（C语言）（西工大数据结构）

千次阅读 2021-03-18 22:05:21

顺序栈基本操作的实现（C语言）栈基本操作顺序栈定义栈的初始化入栈出栈返回栈顶元素主函数今天自学了下栈，简单实现C语言的栈的基本操作，学艺不精，请多指教。栈栈（stack）又名堆栈，它是一种运算受限的线性表...

今天自学了下栈，简单实现C语言的栈的基本操作，学艺不精，请多指教。

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
“只在一端操作，先入后出”

基本操作

顺序栈定义

typedef int StackElementType;
#define Stack_size 100

typedef struct
{
    StackElementType elem[Stack_size];
    int top;
}SeqStack;

和顺序表何其相似！几乎一模一样，所以线性表是基础，栈和队列只是操作方法罢了。

栈的初始化

void InitStack(SeqStack *S)
{
    S->top=-1;
}

把栈顶“指针”赋为-1

入栈

void Push(SeqStack *S,StackElementType x)//入栈
{
    if(S->top==Stack_size-1) return;
    S->top++;
    S->elem[S->top]=x;
    return ;
}

出栈

void Pop(SeqStack *S,int *e)//出栈，用e返回值
{
    if(S->top==-1)
    {
        printf("STACK EMPTY");
        return ;
    }
    else{
        *e=S->elem[S->top];
        S->top--;
        return ;
    }
}

返回栈顶元素

void GetTop(SeqStack *S,int *e)//返回栈顶元素，这里可传S进去，因为不是对S修改而只读取
{
    if(S->top==-1)
    {
        printf("STACK EMPTY");
        return ;
    }
    else{
        *e=S->elem[S->top];
        return ;
    }
}

几乎和出栈一模一样，只是不动栈顶指针罢了。

主函数

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

typedef int StackElementType;
#define Stack_size 100

typedef struct
{
    StackElementType elem[Stack_size];
    int top;
}SeqStack;

void InitStack(SeqStack *S)
{
    S->top=-1;
}

void Push(SeqStack *S,StackElementType x)//入栈
{
    if(S->top==Stack_size-1) return;
    S->top++;
    S->elem[S->top]=x;
    return ;
}
void Pop(SeqStack *S,int *e)//出栈，用e返回值
{
    if(S->top==-1)
    {
        printf("STACK EMPTY");
        return ;
    }
    else{
        *e=S->elem[S->top];
        S->top--;
        return ;
    }
}

void GetTop(SeqStack *S,int *e)//返回栈顶元素，这里可传S进去，因为不是对S修改而只读取
{
    if(S->top==-1)
    {
        printf("STACK EMPTY");
        return ;
    }
    else{
        *e=S->elem[S->top];
        return ;
    }
}

int main()
{    int e;
    SeqStack S;
    InitStack(&S);
    Push(&S,10);
    Pop(&S,&e);
    printf("%d",e);
    GetTop(&S,&e);
    return 0;

}

运行截图
在这里插入图片描述

今天顺序栈不难，请多指教

收起

展开全文

指针数据结构

顺序栈基本操作的C语言实现（含全部代码实现）--- 数据结构之顺序栈

万次阅读 多人点赞 2020-08-19 09:50:04

1、存储结构 #define Stack_Init_Size 100 #define StackIncrement 10 typedef int ElemType;... // 栈底指针 ElemType *top; // 栈顶指针 int stacksize; // 栈的最大容量 } SqStack; // 方式二 typedef struct {

1、存储结构

#define Stack_Init_Size 100
#define StackIncrement 10
typedef int ElemType;
typedef int Status;

// 方式一（本文采取）
typedef struct {
    ElemType *base; // 栈底指针
    ElemType *top; // 栈顶指针
    int stacksize; // 栈的最大容量
} SqStack;

// 方式二
typedef struct {
    int data[MaxSize];
    int top;
} SeqStack;

2、函数列表

Status InitStack(SqStack *S) 初始化栈
Status GetTopStack(SqStack *S, ElemType *e) 获取栈顶元素，参数e存放栈顶元素的值
Status PushStack(SqStack *S, ElemType e) 进栈，将元素e入栈
Status PopStack(SqStack *S, ElemType *e) 出栈，出栈的元素存放在参数e中
Status EmptyStack(SqStack *S) 判断栈是否为空
Status LengthStack(SqStack *S) 获取栈的实际长度
Status DestroyStack(SqStack *S) 销毁栈
Status StackTraverse(SqStack *S) 遍历栈，打印每个元素

3、完整代码

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

#define Stack_Init_Size 10 // 初始化栈的最大长度
#define StackIncrement 10 // 若栈最大空间不够时，需要增加的长度
typedef int ElemType;
typedef int Status;

typedef struct {
    ElemType *base; // 栈底指针
    ElemType *top; // 栈顶指针
    int stack_size; // 栈的最大长度
} SqStack;

// 初始化栈
Status InitStack(SqStack *S) {
    // 分配初始空间
    S->base = (ElemType *) malloc(Stack_Init_Size * sizeof(ElemType));
    if (!S->base) {
        exit(0);
    }
    S->top = S->base; /// 栈顶与栈底相同
    S->stack_size = Stack_Init_Size; // 栈的最大长度等于初始长度
    return 1;
}

// 判断栈是否为空，只需要判断栈顶指针与栈底指针是否相同即可
Status EmptyStack(SqStack *S) {
    return S->base == S->top;
}

// 获取栈的实际长度，栈顶减去栈底指针即为栈的长度
Status LengthStack(SqStack *S) {
    if (S->top == S->base) {
        return 0;
    }
    return (Status) (S->top - S->base);
}

// 获取栈顶的元素，参数e用来存放栈顶的元素
Status GetTopStack(SqStack *S, ElemType *e) {
    if (S->top == S->base) {
        return 0;
    } 
    *e = *(S->top - 1);
    return 1;
}

// 进栈，参数e是要进栈的元素
Status PushStack(SqStack *S, ElemType e) {
    // 若栈的最大长度不会够用时，重新开辟，增大长度
    if (S->top - S->base >= S->stack_size) {
        S->base = (ElemType *)realloc(S->base, (S->stack_size + StackIncrement) * sizeof(ElemType));
        if (!S->base) {
            return 0;
        }
        // 栈顶指针为栈底指针加上栈之前的最大长度
        S->top = S->base + S->stack_size;
        // 栈当前的最大长度等于栈之前的最大长度与增加的长度之和
        S->stack_size += StackIncrement;
    }
    *S->top++ = e; // 先赋值，后栈顶指针上移
    return 1;
}

// 出栈，参数e用来存放出栈的元素
Status PopStack(SqStack *S, ElemType *e) {
    if (S->base == S->top) {
        return 0;
    }
    *e = *--S->top; // 栈顶指针先下移，后赋值
    return 1;
}

// 销毁栈，释放栈空间，栈顶栈底指针置为NULL，长度置为0
Status DestroyStack(SqStack *S) {
    free(S->base);
    S->base = S->top = NULL;
    S->stack_size = 0;
    return 1;
}

// 遍历栈，依次打印每个元素
Status StackTraverse(SqStack *S) {
    ElemType *p;

    if (S->top == S->base) {
        printf("Stack is NULL.\n");
        return 0;
    }
    p = S->top;
    // 由栈顶依次向下遍历
    while (p > S->base) {
        p--;
        printf("%d ", *p);
    }
    printf("\n");
    return 1;
}

int main() {
    SqStack q, *S;
    S = &q;

    int i, n, e;

    printf("Creat a NULL Stack :\n");
    InitStack(S);

    printf("input the length of the Stack :\n");
    scanf("%d", &n);

    for (i = 1; i <= n; i++) {
        scanf("%d", &e);
        PushStack(S, e);
    }
    printf("Is the stack NULL?\n");

    if (EmptyStack(S)) {
        printf("Yes!\n");
    } else {
        printf("No!\n");
    }
    printf("The length of stack is %d.\n", LengthStack(S));

    printf("The stack is :\n");
    StackTraverse(S);

    GetTopStack(S, &e);
    printf("The top data is %d.\n", e);

    printf("input the data to the stack :\n");
    scanf("%d", &e);
    PushStack(S, e);
    printf("The new stack is :\n");
    StackTraverse(S);

    printf("Delete the top data : ");
    e = PopStack(S, &e);
    printf("%d\n", e);

    printf("The new stack is :\n");
    StackTraverse(S);

    printf("Destroy the stack :\n");
    DestroyStack(S);
    StackTraverse(S);

    return 0;
}

在这里插入图片描述

收起

展开全文

数据结构

数据结构-栈操作-用链表实现栈基本操作
千次阅读 2019-06-13 18:15:07

原文链接:...数据结构中的栈基本操作,我这里是也是为了学习记录我自己的书写的代码过程.其中包含取栈的新建,新增元素,删除元素,取指定索引值,向元素尾部追加元素等等! 1、场景 1.1、中文描述数据结...

收起

数据结构链表 go golang
顺序栈的基本操作
千次阅读 多人点赞 2022-04-18 09:00:55

编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈。

收起

数据结构
栈的基本操作
千次阅读 多人点赞 2021-08-25 19:15:43

对于栈这一数据结构，我首先写一下它的基本概念。栈(stack)是仅限定在表尾进行插入和删除操作的线性表。栈就是一个线性表，只不过，栈的Insert 和 delete只能在表尾。普通的线性表，在表中的任意位置都可以...

收起

数据结构算法 c语言
顺序栈的基本操作和实现
2011-11-22 19:31:53

顺序栈的基本操作和实现顺序栈的基本操作和实现

收起
数据结构栈的操作实例详解
2020-08-30 03:16:45

主要介绍了数据结构顺序栈的定义、初始化、空栈判断、入栈、出栈操作的相关资料,需要的朋友可以参考下

收起
实现栈的基本操作（c语言）
千次阅读 2022-04-03 11:22:43

一、实现顺序栈的基本操作 二、各操作的代码详解 1.定义顺序栈 2.构建顺序栈 3.顺序栈的判空 4.顺序栈的入栈 5.顺序栈的出栈 6.读取顺序栈的栈顶元素总代码顺序栈的介绍顺序栈是指利用顺序存储结构...

收起

数据结构 c语言
C++ 栈基本操作
千次阅读 2017-12-21 11:06:26

一：目的用C++实现栈的基本操作；一：实现 1. 首先定义栈的结构和类，书写在stack.h中

收起

C++
8583 顺序栈的基本操作.cpp
2020-04-29 14:28:42

分享一下我写的顺序栈基本操作，顺便蹭一下勋章哈哈哈，这个是c++写的，包含了创建一个空的顺序栈，并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法

收起

数据结构
栈的基本操作（c语言实现）
千次阅读 2022-03-25 16:53:48

数据结构栈顺序栈顺序栈与顺序链表差不多，初始化时都要有一个一维数组和一个用来存放下标的变量（可以理解为指针）顺序栈已满和已空的标志： ...进栈操作 void push(stack *&s,elemtype e) { i

收起

数据结构
顺序栈基本操作（入栈和出栈）C语言详解
2021-10-11 08:52:50

顺序栈基本操作（入栈和出栈）C语言详解栈的具体实现（1）顺序栈（2）链栈栈的应用（1）回退（2）框号应用问题（3）进制转换顺序栈的基本操作：顺序表中设定一个实时指向的栈顶元素结构的变量。设置...

收起

c语言数据结构 c++
C++完整代码数据结构栈的基本操作
千次阅读 2021-12-06 01:00:33

栈的一些基本操作 栈的概念: 栈（stack）又名堆栈，是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作入栈，就是把新元素放...

收起

c++ 数据结构
栈的基本操作(C语言)
千次阅读 2021-11-02 10:34:39

1.数组：选用数组来做栈的存储结构，只需要在数组末尾进行操作即可，完美的避开了数组操作中挪动数据的缺陷，显然可以选择数组来做栈的存储结构 2.单链表：因为栈是在线性表的一段进行操作，所以得想想实在链表头...

收起

c语言链表数据结构
栈的基本操作(顺序栈)
千次阅读 2021-12-11 20:36:53

栈的部分基本操作图示栈的其他基本操作 代码说明文章作于数据结构课程学习过程，旨在用图示区分理解栈的各种基本操作，如有错误，欢迎指正。(解释：文中矩形框表示实际储存空间，矩形框+圈表示该储存...

收起

c++ 数据结构
Python实现基本数据结构中栈的操作示例
2020-12-25 14:57:41

本文实例讲述了Python实现基本数据结构中栈的操作。分享给大家供大家参考，具体如下： #! /usr/bin/env python #coding=utf-8 #Python实现基本数据结构---栈操作 class Stack(object): def __init__(self,size): ...

收起
栈的基本操作算法实现(C语言)
2019-03-26 01:26:14

NULL 博文链接：https://linuxdev.iteye.com/blog/1148109

收起
C语言实现栈的基本操作（超详细注释）
千次阅读 2022-04-01 00:01:56

这篇文章更新了数据结构中栈的内容。在第一次写这个内容的时候，又出现了一大堆内存访问冲突。我本以为我对指针已经有深刻的了解了，经过这次我发现我还是有很多的不足。还是没有完全理解指针。所以对我的代码又进行...

收起

数据结构 c语言经验分享
栈基本操作的java代码实现（建栈，初始化栈、进栈、出栈）
千次阅读 2020-07-15 13:28:45

定义栈 /** * className:Statck * * @author:zjl * @version:0.1 * @date:2020/7/1512:22 * @since:jdk1.8 */ public class Statck { private int maxSize;//栈最大容量 private int top;//栈顶指针（始终...

收起

stack java 数据结构
带头节点的链式存储栈基本操作（进栈、出栈、获取栈顶元素）
千次阅读 2020-05-11 17:57:32

带头节点的链式存储栈基本操作（进栈、出栈、获取栈顶元素）栈链式存储的特点链式存储栈的基本操作代码实现测试结果栈链式存储的特点链式存储，可以带头结点，或不带头结点，本篇介绍带头结点的链式存储栈的基本...

收起

数据结构链表

数据结构顺序栈基本操作（C/C++实现）

涉及基本运算流程

GitHub地址（包含.cpp文件和可执行程序exe）

源代码（经VS2015、devC++编译器运行通过）

顺序栈基本操作

顺序栈基本操作.cpp

顺序栈的基本操作实现

顺序栈基本操作代码实现

顺序栈基本操作代码实现

顺序栈基本操作的实现（C语言）（西工大数据结构）

顺序栈基本操作的实现（C语言）

栈

基本操作

顺序栈定义

栈的初始化

入栈

出栈

返回栈顶元素

主函数

顺序栈基本操作的C语言实现（含全部代码实现）--- 数据结构之顺序栈

1、存储结构

2、函数列表

3、完整代码

数据结构-栈操作-用链表实现栈基本操作

顺序栈的基本操作

栈的基本操作

顺序栈的基本操作和实现

数据结构 栈的操作实例详解

实现栈的基本操作（c语言）

C++ 栈基本操作

8583 顺序栈的基本操作.cpp

栈的基本操作（c语言实现）

顺序栈基本操作（入栈和出栈）C语言详解

C++完整代码 数据结构栈的基本操作

栈的基本操作(C语言)

栈的基本操作(顺序栈)

Python实现基本数据结构中栈的操作示例

栈的基本操作算法实现(C语言)

C语言实现栈的基本操作（超详细注释）

栈基本操作的java代码实现（建栈，初始化栈、进栈、出栈）

带头节点的链式存储栈基本操作（进栈、出栈、获取栈顶元素）

栈的基本操作

数据结构栈的操作实例详解

C++完整代码数据结构栈的基本操作