精华内容
下载资源
问答
  • 顺序栈基本操作

    2017-03-04 16:03:26
    数据结构 顺序栈基本操作
  • 顺序栈基本操作实现 实验要求: (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;
    }
    
    展开全文
  • 顺序栈基本操作.cpp

    2019-11-21 10:30:11
    初学数据结构,不是很熟悉,大家一起共同学习,多交流一下,顺序栈基本操作,如有错误请大家多多指教,我会及时更正
  • 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);
    
        e = 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;
    }
    

    在这里插入图片描述

    展开全文
  • 顺序栈,即用顺序表实现栈存储结构。通过前面的学习我们知道,使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则,本节就 "如何使用顺序表模拟栈以及实现对栈中数据的基本操作(出栈和入栈)&...

    顺序,即用顺序表实现栈存储结构。通过前面的学习我们知道,使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则,本节就 "如何使用顺序表模拟栈以及实现对栈中数据的基本操作(出栈和入栈)" 给大家做详细介绍。

    如果你仔细观察顺序表(底层实现是数组)和栈结构就会发现,它们存储数据的方式高度相似,只不过栈对数据的存取过程有特殊的限制,而顺序表没有。

    例如,我们先使用顺序表(a 数组)存储 {1,2,3,4},存储状态如 1 所示:

    顺序表存储 {1,2,3,4}

                                                             图 1 顺序表存储 {1,2,3,4}


    同样,使用栈存储结构存储 {1,2,3,4},其存储状态如图 2 所示:

    展开全文
  • 顺序栈基本操作的实现(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/C++实现)

    千次阅读 多人点赞 2019-10-26 02:38:53
    数据结构顺序栈基本操作(C/C++实现) 注意:本代码为了测试运行默认含有操作所需数据,如有需要可自己增删改相关数据 涉及基本运算流程 1.初始化栈 2.判断栈是否非空 3.元素依次进栈 4.判断栈是否非空 5.输出出栈...
  • 双端顺序栈基本操作

    千次阅读 2017-05-20 17:19:03
    #include ...typedef struct //定义一个双端顺序栈 { ElemType data[M];//栈区 int top[2];//top[0]和top[1]分别为两个栈顶指示器 } SeqStack; void InitStack(SeqStack *s)//创建一个双端顺序栈 {
  • 顺序栈基本操作和实现顺序栈基本操作和实现
  • 顺序栈基本操作

    千次阅读 2020-04-20 08:23:37
    顺序栈基本操作 1、定义: ​ 作为一种限定性线性表,是将线性表的插入和删除运算限制为仅在表的一端进行。(先进后出) 2、栈的存储结构。 顺序栈:用顺序储存结构实现的栈。是利用一组地址连续的储存单元依次...
  • 顺序栈基本操作的实现 编程实现顺序栈的初始化、入栈、出栈、取栈顶元素和计算栈中元素个数等基本操作。 输入 第一行为入栈元素的个数; 第二行依次为入栈的元素; 出栈操作的次数n. 输出 输出n次出栈后的...
  • // 顺序栈基本操作 #include <iostream> #include <fstream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define MAXSIZE 50 // 存储空间的初始分配数量 typedef ...
  • 顺序栈基本操作C/C++代码实现

    万次阅读 多人点赞 2020-06-03 11:40:13
    顺序栈结构: 设顺序栈为S,需要注意的如下: 入栈: 栈满时 S.top-S.base==S.stacksize 出栈: 栈空时 S.top == S.base 取栈顶元素: ++会改变自身值,而-1不会改变,故返回*(S.top-1); 顺序栈特点: 由于顺序栈和...
  • 顺序栈基本操作以及实现

    千次阅读 2020-04-10 16:01:32
    刚学习到了数据结构的顺序栈的储存结构,以此做个记录,防止忘记以及帮助迷的人 顺序表的基本操作以及实现: Status Stack_Init(StackPtr s);//初始化栈 void Stack_Destroy(StackPtr s);//销毁栈 int Length_Stack...
  • 顺序栈基本操作及实现(C/C++)

    千次阅读 2020-06-06 21:45:26
    顺序栈基本操作顺序栈基本操作代码实现 顺序栈基本操作 //1.顺序栈的初始化 //2.判断顺序栈是否为空 //3求顺序栈的长度 //4.清空顺序栈 //5.销毁顺序栈 //6.顺序栈进栈 //7.顺序栈出栈 //8.取顺序栈的...
  • 1.初始化; 2.将元素10,20,30,40,50,60,70,80,90入栈; 3.将元素90出栈; 4.取此时的栈顶元素。
  • “如何使用顺序表模拟以及实现对中数据的基本操作(出栈和入栈)” 给大家做详细介绍。 如果你仔细观察顺序表(底层实现是数组)和结构就会发现,它们存储数据的方式高度相似,只不过对数据的存取过程有特殊...
  • (stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为底。向一个插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶...
  • 栈——顺序栈基本操作

    千次阅读 2018-10-22 21:19:20
    顺序栈:采用顺序存储结构实现的栈,即利用一组地址连续的存储单元依次存放自栈底的数据元素,同时由于栈操作的特殊性,还必须附设一个位置指针top来动态的指示 栈顶元素在顺序栈中的位置。一般top=-1来表示空栈. ...
  • 用Java实现顺序栈基本操作,采用泛型结构,可以适应更多场合运用,避免了上篇文章只是储存int类型的单链表的缺点。本文以String 和Integer为例简单介绍。作为知识的总结与理解 提示:以下是本篇文章正文内容。 一...
  • 顺序栈的几种基本操作

    千次阅读 2018-11-27 12:24:07
    cout顺序栈不存在!"; return FALSE; } else { free(s.base); s.stacksize = 0; s.base=NULL; cout销毁成功!"; return OK; } } //将栈置空 int ClearStack(SqStack &s) { if(s.base == NULL) { ...
  • (5) 实验心得 实验课成绩=考勤成绩(10)+ 实验报告成绩(20) 实验报告共收4份实验报告 数据结构实验 实验二 顺序栈的建立及基本操作 实验目的 了解顺序栈的结构特点及有关概念 掌握顺序栈建立及基本操作算法 实验二 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 177,347
精华内容 70,938
关键字:

顺序栈的基本操作