精华内容
下载资源
问答
  • 数据结构顺序栈基本操作(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;
    }
    
    
    
    
    更多相关内容
  • 顺序栈基本操作

    2017-03-04 16:03:26
    数据结构 顺序栈基本操作
  • 顺序栈基本操作.cpp

    2019-11-21 10:30:11
    初学数据结构,不是很熟悉,大家一起共同学习,多交流一下,顺序栈基本操作,如有错误请大家多多指教,我会及时更正
  • 顺序基本操作实现 实验要求: (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语言)栈基本操作顺序栈定义栈的初始化入栈出栈返回栈顶元素主函数 今天自学了下栈,简单实现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;
    
    }
    
    

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

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

    展开全文
  • 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;
    }
    

    在这里插入图片描述

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

    千次阅读 多人点赞 2022-04-18 09:00:55
    编程实现的以下基本操作:建,取栈顶元素,入栈,出栈。
  • 基本操作

    千次阅读 多人点赞 2021-08-25 19:15:43
    对于这一数据结构,我首先写一下它的基本概念。 (stack)是仅限定在表尾进行插入和删除操作的线性表。 就是一个线性表,只不过,的Insert 和 delete只能在表尾。 普通的线性表,在表中的任意位置都可以...
  • 顺序基本操作和实现顺序基本操作和实现
  • 主要介绍了数据结构 顺序的定义、初始化、空栈判断、入栈、出栈操作的相关资料,需要的朋友可以参考下
  • 实现基本操作(c语言)

    千次阅读 2022-04-03 11:22:43
    一、实现顺序基本操作 二、各操作的代码详解 1.定义顺序 2.构建顺序 3.顺序的判空 4.顺序的入栈 5.顺序的出栈 6.读取顺序的栈顶元素 总代码 顺序的介绍 顺序是指利用顺序存储结构...
  • C++ 栈基本操作

    千次阅读 2017-12-21 11:06:26
    一:目的 用C++实现基本操作; 一:实现 1. 首先定义的结构和类,书写在stack.h中
  • 分享一下我写的顺序栈基本操作,顺便蹭一下勋章哈哈哈,这个是c++写的,包含了创建一个空的顺序栈,并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法
  • 基本操作(c语言实现)

    千次阅读 2022-03-25 16:53:48
    数据结构 顺序 顺序与顺序链表差不多,初始化时都要有一个一维数组和一个用来存放下标的变量(可以理解为指针) 顺序已满和已空的标志: ...进栈操作 void push(stack *&s,elemtype e) { i
  • 顺序栈基本操作(入栈和出栈)C语言详解 栈的具体实现(1)顺序栈(2)链栈 栈的应用(1)回退 (2)框号应用问题 (3)进制转换 顺序栈的基本操作: 顺序表中设定一个实时指向的栈顶元素结构的变量。 设置...
  • C++完整代码 数据结构基本操作

    千次阅读 2021-12-06 01:00:33
    的一些基本操作 的概念: (stack)又名堆栈,是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶,相对地,把另一端称为底。向一个插入新元素又称作入栈,就是把新元素放...
  • 基本操作(C语言)

    千次阅读 2021-11-02 10:34:39
    1.数组:选用数组来做的存储结构,只需要在数组末尾进行操作即可,完美的避开了数组操作中挪动数据的缺陷,显然可以选择数组来做的存储结构 2.单链表:因为是在线性表的一段进行操作,所以得想想实在链表头...
  • 基本操作(顺序)

    千次阅读 2021-12-11 20:36:53
    的部分基本操作图示 的其他基本操作 代码 说明 文章作于数据结构课程学习过程,旨在用图示区分理解的各种基本操作,如有错误,欢迎指正。(解释:文中矩形框表示实际储存空间,矩形框+圈表示该储存...
  • 本文实例讲述了Python实现基本数据结构中操作。分享给大家供大家参考,具体如下: #! /usr/bin/env python #coding=utf-8 #Python实现基本数据结构---栈操作 class Stack(object): def __init__(self,size): ...
  • NULL 博文链接:https://linuxdev.iteye.com/blog/1148109
  • 这篇文章更新了数据结构中的内容。在第一次写这个内容的时候,又出现了一大堆内存访问冲突。我本以为我对指针已经有深刻的了解了,经过这次我发现我还是有很多的不足。还是没有完全理解指针。所以对我的代码又进行...
  • 定义 /** * className:Statck * * @author:zjl * @version:0.1 * @date:2020/7/1512:22 * @since:jdk1.8 */ public class Statck { private int maxSize;//最大容量 private int top;//栈顶指针(始终...
  • 带头节点的链式存储栈基本操作(进栈、出栈、获取栈顶元素)栈链式存储的特点链式存储栈的基本操作代码实现测试结果 栈链式存储的特点 链式存储,可以带头结点,或不带头结点,本篇介绍带头结点的链式存储栈的基本...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 432,662
精华内容 173,064
关键字:

栈的基本操作