精华内容
下载资源
问答
  • 顺序栈实现C++

    2021-01-22 21:14:06
    如果要实现一个顺序栈,首先我们就需要有个静态数组,同时还需要有个数组的长度。其次呢我们需要有两个指针,一个指针指向栈顶,一个指向栈底(主要是方便入栈,出栈操作方便) 栈的初始化 有了这个思路之后,我们就...

    分析

    如果要实现一个顺序栈,首先我们就需要有个静态数组,同时还需要有个数组的长度。其次呢我们需要有两个指针,一个指针指向栈顶,一个指向栈底(主要是方便入栈,出栈操作方便)

    栈的初始化

    有了这个思路之后,我们就可以进行栈的初始化了。那么初始化的需要让咱们栈有个固定长度吧,那我们就得给他分配一个数组,其次呢,一开始阶段,我们栈里(目前是个数组)是什么值都没有的,所以我们就需要让两个指针指向数组的最底部吧。有了这些基础之后,我们就可以用代码实现啦。

    在这里插入图片描述
    代码见下: 内联代码片

    1.定义一个长度	#define MAXSIZE 100
    2.需要定义一个结构体,存长度以及两个指针 。来表示栈
    3.定义一个int类型的新变量typedef int SElemType;  (为了方便而定义,不定义用int也行)
    4.初始化(即定义一个数组,和两个指针指向相等)。
    
    //顺序栈(后进先出)
    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100
    typedef int SElemType;
    
    typedef  struct{
        SElemType *base;
        SElemType *top;
        int stacksize;//最大容量
    }SqStack;
    //1.初始化
    void init(SqStack &S){
        S.base=new SElemType[MAXSIZE];//定义一个int类型 长度为MAXSIZE的数组
        if(!S.base) exit; //如果不存在就退出
        S.top=S.base; //栈顶和栈底指向相等
        S.stacksize=MAXSIZE;  //栈的长度
    }
    

    入栈

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

    入栈很明显,就是将一个值存入到栈,并且处于栈顶部
    这里入栈操作我们需要考虑, 栈会不会满?,满了怎么操作。如果说栈满了,我们就不能在进行操作了,我们就友情提示一下,若不满,我们就可以操作,这时,我们就把需要入栈的值e存入栈
    具体操作:

    1.先判断栈是否满
    2.不满,就先将值存入栈(因为此时初始化指向的值为空嘛!可以看初始化的图理解)
    3.然后就需要将栈顶指针向上移动啦!
    

    代码如下:

    //2.入栈
    void push(SqStack &S,SElemType e){
        if(S.top-S.base==S.stacksize) printf("该栈已满");
        *S.top=e;
        S.top++;
        printf("入栈成功");
    }
    

    出栈

    在这里插入图片描述

    出栈,顾名思义,就是将栈内元素拿出来,当然根据栈的规则,先进后出原则,所以我们应将栈顶的元素先取出来,但是呢,我们的栈是不是空的?,如果空的还有什么能出栈呢?,所以出战要进行判断栈是否为空

    代码如下:

    1.判断栈是否为空
    2.先取出栈顶元素,用一个变量存储
    3.将栈顶指针向下移动一个单位
    
    //3.出栈
    void pop(SqStack &S,SElemType e){
        if(S.top==S.base) printf("该栈为空");
        S.top--;
        e=*S.top;
        printf("出栈成功");
    
    }
    

    遍历取栈内元素

    主要分为从栈顶输出栈底输出两种方式
    代码如下:
    栈顶输出

    //6.遍历输出栈内元素(从栈顶进行输出)
    void printStackTop(SqStack S){
          printf("栈顶:");
    while(S.top!=S.base){
        printf("%d ",*(S.top-1));   //因为一开始栈顶指针指向有值的上方,可以看入栈的图例
        S.top--;
    }
    printf("\n");
    }
    

    栈底输出

    //5.遍历输出栈内元素(从栈底进行输出)
    void printStackBottom(SqStack S){
       printf("栈底:");
       SElemType *p=S.base;
       while(p!=S.top){
        printf("%d  ",*p);
        p++;
    
       }
       printf("\n");
    
    }
    

    取栈顶元素

    基本和取值类似,这里就不多说!

    //4.取栈顶元素
    SElemType  getTop(SqStack S){
        //非栈空时返回
        if(S.top!=S.base){
            return *(S.top-1);
        }
    }
    

    🆗基本上顺序栈就这么多!
    但是我之前遇到一个问题就是为什么有什么需要&有时候不需要&呢
    比如pop(SqStack &S,SElemType e)和printStackTop(SqStack S)

    于是我找同学得出的结论就是

    	就是说如果我需要改变栈内的值就需要用到&,如果只是简单的做输出而不需要改变内部值就不需要&
    

    完整代码

    //顺序栈(后进先出)
    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100
    typedef int SElemType;
    
    typedef  struct{
        SElemType *base;
        SElemType *top;
        int stacksize;//最大容量
    }SqStack;
    
    /**
    满足先进后出原则  。所以7是按照次原则实现
    1.初始化
    2.判断是否为空
    3.判断是否满
    4.入栈
    5.出栈
    6.取栈顶元素
    7.遍历输出栈内元素
    */
    //1.初始化
    void init(SqStack &S){
        S.base=new SElemType[MAXSIZE];
        if(!S.base) exit;
        S.top=S.base;
        S.stacksize=MAXSIZE;
    }
    
    //2.入栈
    void push(SqStack &S,SElemType e){
        if(S.top-S.base==S.stacksize) printf("该栈已满");
        *S.top=e;
        S.top++;
        printf("入栈成功");
    }
    //3.出栈
    void pop(SqStack &S,SElemType e){
        if(S.top==S.base) printf("该栈为空");
        S.top--;
        e=*S.top;
        printf("出栈成功");
    
    }
    //4.取栈顶元素
    SElemType  getTop(SqStack S){
        //非栈空时返回
        if(S.top!=S.base){
            return *(S.top-1);
        }
    }
    //5.遍历输出栈内元素(从栈底进行输出)
    void printStackBottom(SqStack S){
       printf("栈底:");
       SElemType *p=S.base;
       while(p!=S.top){
        printf("%d  ",*p);
        p++;
    
       }
       printf("\n");
    
    }
    //6.遍历输出栈内元素(从栈顶进行输出)
    void printStackTop(SqStack S){
          printf("栈顶:");
    while(S.top!=S.base){
        printf("%d ",*(S.top-1));
        S.top--;
    }
    printf("\n");
    }
    
    int main(){
    
    SqStack S;
    int e;
     printf("初始化顺序栈");
    init(S);//初始化
    //进行输入,准备入栈操作
    printf("请输入一个要入栈的元素(-1表示结束):");
    scanf("%d",&e);
    while(e!=-1){
        push(S,e);
        printf("请输入一个要入栈的元素(-1表示结束):");
        scanf("%d", &e);
    }
    //进行输出
    printStackBottom(S);
    
    
    printf("出栈测试:");
    pop(S,e);
    printStackBottom(S);
    printf("取栈顶元素测试:");
    e=getTop(S);
    printf("取出的栈顶元素为:%d\n",e);
    }
    
    
    展开全文
  • 顺序栈实现出栈入栈

    2021-08-22 19:25:33
    使用顺序栈,接收键盘的输入,实现如下功能: 输入数字时,依次入栈。 输入字母时,依次出栈。 每次入栈或者出栈,都将顺序栈中的各个元素输出出来。 代码: #include <stdio.h> #include <stdlib.h> ...

    使用顺序栈,接收键盘的输入,实现如下功能:

    • 输入数字时,依次入栈。
    • 输入字母时,依次出栈。
    • 每次入栈或者出栈,都将顺序栈中的各个元素输出出来。
      代码:
    #include <stdio.h>
    #include <stdlib.h>
    #define DATATYPE int
    typedef DATATYPE datatype;
    
    typedef struct
    {
        datatype *data;
        int size;
        int top;
    } seqStack;
    //初始化栈
    seqStack *initStack(int size)
    {
        seqStack *s = (seqStack *)malloc(sizeof(seqStack));
        if (s != NULL)
        {
            s->data = (datatype *)malloc(sizeof(datatype) * size);
            if (s->data == NULL)
            {
                free(s);
                return NULL;
            }
        }
        s->size = size;
        s->top = -1;
        return s;
    }
    //判断栈是否满
    int ifFull(seqStack *s)
    {
        if (s->top == s->size - 1)
            return 1;
    }
    //判断栈是否空
    int ifNULL(seqStack *s)
    {
        if (s->top == -1)
            return 1;
    }
    //入栈
    int Push(seqStack *s, int data)
    {
        if (ifFull(s) == 1)
            return 0;
        s->data[++(s->top)] = data;
        return 1;
    }
    //出栈
    int Pop(seqStack *s)
    {
        if (ifNULL(s))
            return 0;
        s->top--;
        return 1;
    }
    //显示栈中数据
    void show(seqStack *s, int flag)
    {
        if (flag == 1)
        {
            printf("栈中数据:");
            while (s->top != -1)
                printf("%c ", s->data[(s->top)--]);
        }
        if (flag == 0)
        {
            printf("栈中数据:");
            while (ifNULL(s) != 1)
                printf("%c ", s->data[(s->top)--]);
        }
    }
    
    int main()
    {
        char a;
        int flag;
        seqStack *s = initStack(100);
        printf("输入数字'0'为结束标志,输入字母'a'为结束标志:\n");
        while (1)
        {
            scanf("%c", &a);
            if (a >= '0' && a <= '9')
            {
                flag = 1;
                if (a == '0') //结束标志
                    break;
                Push(s, a);
            }
            else if (a >= 'a' && a <= 'z' || a >= 'A' && a <= 'Z')
            {
                flag = 0;
                if (a == 'a') //结束标志
                    break;
                Pop(s);
            }
        }
        show(s, flag);
    }
    
    展开全文
  • 顺序栈实现回文判定

    2021-10-27 17:39:57
    一.8.。回文是只正读和返读都相同的字符序列,如“abba”和“abdba”均是回文,但“good”不是回文。...#define MAXLEN 1024 //定义顺序栈的最大长度 #define MAXSIZE 1024 //定义数组的最大长度 typed

    一.8.。回文是只正读和返读都相同的字符序列,如“abba”和“abdba”均是回文,但“good”不是回文。试写一个算法判定给定的字符向量是否为回文。
    思路:

    1. 定义字符数组,将键入字母;
    2. 将数组元素入栈,再栈和数组元素进行比较;
    3. 利用栈的顺序存储结构

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

    #define MAXLEN 1024 //定义顺序栈的最大长度
    #define MAXSIZE 1024 //定义数组的最大长度
    typedef int Status;
    typedef char Elem;
    typedef struct SqStack{
    Elem data[MAXLEN];
    int top; //栈顶元素的数组下标top
    }SqStack;

    Status InitStack(SqStack *S){
    S->top=-1;
    return 1;
    }

    Status Push(SqStack *S,Elem e){
    if(S->top ==MAXLEN-1)
    {
    printf(“栈满,增加元素失败。”);
    return;
    }
    S->top++; //栈顶指针加一
    S->data[S->top]; //字母加入数组
    return 1;
    }

    Status Pop(SqStack *S,Elem *e){
    if(S->top==-1)
    {
    printf(“栈空,读取元素失败。”);
    return;
    }
    *e=S->data[S->top]; //读取字母
    S->top–; //栈顶指针减一
    return 1;
    }
    //判断回文函数
    Status Symmetry(Elem data[]){
    Elem e;
    SqStack S;
    InitStack(&S);
    for(int i = 0;i<S.top+1;i++) //数组元素入栈
    Push(&S,data[i]);
    for(int i = 0;i<S.top+1;i++) //出栈并依次把元素和数组元素比较
    {
    Pop(&S,&e);
    if(data[i] != e) //一旦存在不相同,即返回0
    return 0;
    }
    return 1;
    }

    int main(void){
    Elem data[MAXSIZE]; //定义长度为MAXSIZE的数组
    printf(“请输入要判断的字母序列:\n”);
    gets(data); //键盘输入需要判断的字母序列
    if(Symmetry(data))
    printf(“该字母序列是回文。”);
    else
    printf(“该字母序列不是回文。”);
    return 0;
    }
    测试结果

    展开全文
  • 栈实现括号匹配:依次扫描所有字符,遇到左括号则入栈,遇到右括号则弹出栈顶元素检查是否匹配。 匹配失败情况: 1、左括号单身 2、右括号单身 3、左右括号不匹配 #include <iostream> #include <...

    主要思想:
    用栈实现括号匹配:依次扫描所有字符,遇到左括号则入栈,遇到右括号则弹出栈顶元素检查是否匹配。 

    匹配失败情况:
    1、左括号单身
    2、右括号单身
    3、左右括号不匹配

    #include <iostream>
    #include <stdio.h>
    
    //定义一个结构体
    #define MaxSize 10
    typedef struct
    {
        char data[MaxSize];
        int top;
    }SqStack;
    //初始化
    void InitStack(SqStack &S)
    {
        S.top = -1;
    }
    //判断栈是否为空
    bool StackEmpty(SqStack &S)
    {
        if(S.top == -1)
            return true;
        else
            return false;
    }
    //新元素入栈
    bool Push(SqStack &S,char x)
    {
        //先判断栈是否已经满了
        if(S.top == MaxSize-1)
            return false;
        S.top = S.top+1;
        S.data[S.top] = x;
        return true;
    }
    //出栈,用x返回
    bool Pop(SqStack &S,char &x)
    {
        //先判断是否为空
        if(S.top == -1)
            return false;
        x = S.data[S.top];
        S.top = S.top-1;
        return true;
    }
    
    //括号匹配核心代码
    bool bracket(char str[],int length)
    {
        SqStack S;
        InitStack(S);
        for(int i = 0;i<length;i++)
        {
            if(str[i]=='['||str[i]=='{'||str[i]=='(')
                {
                    Push(S,str[i]);
                }
                else
                {
                    if(StackEmpty(S))
                        return false;
    
                    char topElem;
                    Pop(S,topElem);
                    if(str[i]==')'&&topElem!='(')
                        return false;
                    if(str[i]==']'&&topElem!='[')
                        return false;
                    if(str[i]=='}'&&topElem!='{')
                        return false;
    
                }
        }
        return StackEmpty(S);
    }
    //主函数
    int main()
    {
        char x;
        char str[]={'[','(',']',']'};
        int lenth = sizeof(str)/sizeof(char);
        for(int i= 0;i<lenth;i++)
        {
            printf("%c",str[i]);
        }
        printf("\n");
        if(bracket(str,lenth))
        {
            printf("匹配成功");
        }
        else
        {
            printf("匹配失败");
        }
        return 0;
    
    
    }
    

    展开全文
  • 展开全部用顺序栈实现数制e69da5e6ba9062616964757a686964616f31333335343436转换的Java程序如下:importjava.util.Scanner;importjava.util.Stack;publicclassjinzhi3{publicstaticvoidmain(Stringarg[]){Scannery=...
  • 顺序栈实现十进制和八进制之间的转换顺序栈实现十进制和八进制之间的转换(1)首先实现栈的初始化,既申请固定大小的数组空间,存储数据,用到的方法是 int InitStack( struct sqstack *s );(2)接下来就是让数据入栈 ...
  • 输入样例: 11 2 3 + *# 输出样例: 55 //顺序栈实现后缀表达式计算 //author:Mitchell //data:3.16 #include using namespace std; class stack { private: double* st; int size; int top; public: stack(int ...
  • #include #define M 100typedef int ElemType;typedef struct{ElemType data[M];...//初始化void InitStack(Stack *s){s->top = -1;}int Push(Stack *s,ElemType e){if (s->top == M-1){printf("满\...
  • 顺序栈实现十进制转换成二进制 原理很简单,只是用来实验一下顺序栈的功能 首先还是.h文件 #ifndef __SEQSTACK__ #define __SEQSTACK__ typedef struct stack { int *first;//栈的首地址 int maxlen; int top; }...
  • 利用顺序栈实现数制转换 #include<stdio.h> //3-1存储结构 #define MAXSIZE 100 typedef struct { ​ int *base; ​ int *top; ​ int stacksize; }SqStack; //3-2初始化 void Init(SqStack &S) { ​ S....
  • CSDN的朋友们,你们好哇哈哈哈哈哈哈哈,我好久没有更新啦!!! 大家猜猜我这段时间都去干啥了哇!...虽然使用c/c++开发基于MFC对话框使用socket实现服务器端与多客户端商家端通信!现在好多公司都使
  • 我觉得这是一个非常非常简单的程序,就...直接写在主函数里了 #include<iostream> #include<stdlib.h> using namespace std; #define MAX 20 ... "请选择你要进行的进制抓换的类型:
  • C语言顺序栈实现代码

    2021-05-23 04:03:53
    顺序栈 :它是顺序表的一种,具有顺序表同样的存储结构,由数组定义,配合用数组下标表示的栈顶指针top(相对指针)完成各种操作。sqstack.h //顺序栈头文件(在内存中分配一段连续的存储空间存放入栈的相关数据)#...
  • #include #define MAX 20typedef struct{int data[MAX];int top;}SeqStack;SeqStack* Init(){SeqStack *s;s = (SeqStack *)malloc(sizeof(SeqStack));s->top = -1;return s;}void Destroy(SeqStack *s){free(s);...
  • 为空时,top值为0. public SqStack(int maxSize){ top=0;//初始化top为0 stackElem=new Object[maxSize];//为分配maxSize个储存单位 } public void clear() {//清空 top=0; } public boolean isEmpty...
  • 用C语言顺序栈实现十进制和二进制的转换#include#include#include#define M 100typedef int datatype;typedef struct{datatype data[M];int top;}seqstack;void InitStack(seqstack *s){ //初始化顺序栈s->top=-1...
  • 本项目是对C语言数据结构这门课程中的一个课题——《顺序栈的定义、出栈、入栈、判满、判空》的一个个人总结; 可以用于存储学生的姓名和单科成绩,最多可录入50个学生的姓名与其成绩; 本程序的功能有: 1.添加...
  • 利用栈实现算术表达式求值(Java语言描述) 利用栈实现算术表达式求值(Java语言描述) 算术表达式求值是栈的典型应用,自己写栈,实现Java栈算术表达式求值,涉及栈,编译原理方面的知识.声明:部分代码参考自茫茫大海的...
  • 使用数组实现顺序栈也较为简单,在不考虑动态分配空间的前提下,只需要维护一个数组和一个指向栈顶的指针即可 又因为数组为顺序存储,所以可以使用数组下标代替指针来实现对应结构. 简易实现代码如下: #include <...
  • 我是采用了两个值得比较大小判断得(可能比较浪费空间但是代码我感觉简单一点) 首先是定义一个的结构元素,由于是字符串类型就直接定义一个char的数组就可以: typedef struct stack { char data[MAX_SIZE]; //...
  • 最后是顺序栈实现任意进制转换的代码 提示:以下是本篇文章正文内容,下面案例可供参考 一、顺序栈数据结构定义 typedef int DataType; struct seqStack {//有3个数据成员 int MAXNUM;//用于记
  • 顺序栈实现括号匹配 算法思想如下: #include<stdio.h> #include<stdbool.h> #define MAXSIZE 10 typedef struct StackArr { char data[MAXSIZE]; int top; }Stack,*PSTACK; //函数声明 void ...
  • C语言-顺序栈实现

    2021-11-14 22:16:19
    顺序栈是指利用顺序存储结构实现的栈,即 利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素,同时利用数组下标top指示栈顶元素在顺序栈中的位置。因为C语言中数组下标从0开始,这里以top = -1表示空栈。 ...
  • 顺序栈实现(C++)

    2021-07-16 11:27:17
    顺序栈实现 和之前的线性表的实现一样,此处定义的数据类型还是以学生的学号和姓名为例子。 #include <iostream> #include <string> using namespace std; #define MAXNUM 10 typedef struct{ int ...
  • 顺序栈 因为在C语言中学过链表,我就不仔细讲了,(主要是不想再学一遍哈哈)直接从栈与队列开始吧! 文章目录顺序栈一、栈是什么?二、栈的基本操作函数实现1.初始化操作,建立一个空栈2.入栈操作(push)3.出栈...
  • 顺序栈(王道实现)

    2021-05-26 20:35:23
    一 概述 二 备注 三 目录 四 正文 (一) 基本操作 ...//中元素 int top;//指向栈顶 }sqstack; int main() { void initstack(sqstack &s);//初始化 bool stackempty(sqstack s);//判空 bool pu
  • 栈顶:表尾端称为栈顶栈底:表头端称为栈底空栈:不含任何元素的空表称为空栈出栈:从栈中删除一个元素的操作称为出栈入栈:从栈中增加一个元素的操作称为入栈顺序栈实现栈有两种存储实现方法,一种是顺序存储实现,...
  • 这一篇先介绍的一些基本操作,再将应用在数制转换中。代码预处理和的定义代码预处理:#include#include#...顺序存储表示:typedef struct{int stacksize;int *top;int *base;}Stack;一、加工型操作1.构...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 305,775
精华内容 122,310
关键字:

顺序栈的实现

友情链接: 69389605rule_create.rar