数据结构-栈的应用

最新推荐文章于 2022-10-23 22:45:20 发布
最新推荐文章于 2022-10-23 22:45:20 发布
阅读量81 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55000908/article/details/114994110
版权

数值转换


#pragma warning(disable:4996)
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>//OVERFLOW
using namespace std;

//顺序栈
#define STACK_INIT_SIZE 100//存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量
#define ERROR  0
#define OK 1
#define TRUE    1
#define FALSE   0
//typedef  int SElemType;//可以为int,char,……
typedef int SElemType;
typedef int Status;
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;//当前已分配的存储空间
}SqStack;

Status InitStack(SqStack &S);
Status DestroyStack(SqStack &S);
Status ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
Status StackTraverse(SqStack S, Status(*visit)());

//构造一个空栈S
Status InitStack(SqStack &S) {
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(char));
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack &S){
    if(S.base ){
        free(S.base);
        S.base = NULL;
        S.top = NULL;
        S.stacksize = 0;
    }
    return OK;
}


Status ClearStack(SqStack &S){
    if(S.base){
        S.top = S.base;
    }
    return OK;
}

//判断栈是否为空
Status StackEmpty(SqStack S) {
    if (S.top == S.base) return OK;
    else return ERROR;
}

int StackLength(SqStack S)
{
    return (S.top-S.base)/sizeof(SElemType);
}
//若栈不空，则用e返回栈顶元素，并返回ok(1),否则返回error(0)
Status GetTop(SqStack S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {//栈满，追加存储空间
        S.base = (SElemType*)realloc(S.base,
                                     (S.stacksize + STACKINCREMENT) * sizeof(char));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *(S.top++) = e;
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回ok,否则返回error
Status Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(--S.top);
    return OK;
}

Status StackTraverse(SqStack S, Status(* visit)(SElemType)){
    while(S.top > S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}

Status visit(SElemType e){
    printf("%c ", e);
    return OK;
}
//打印栈元素
void PrintStack(SqStack s) {
    if (StackEmpty(s)) return;
    printf("Stack:");
    while (!StackEmpty(s)){
        printf("%c ", *(s.top - 1));
        SElemType e;
        Pop(s, e);
    }
    printf("\n");
}

void conversion(){
    SqStack S;
    InitStack(S);
    SElemType e;
    int n, r;
    printf("输入一个数十进制数和想要转换的进制:\n");
    scanf("%d %d", &n, &r);
    while(n){
        Push(S, n%r);
        n/=r;
    }
    while(!StackEmpty(S)){
        Pop(S,e);
        printf("%d", e);
    }
    printf("\n");
}
//-----------------------

int main() {
    
    conversion();
    return 0;
}

1348 8
2504

括号匹配


#pragma warning(disable:4996)
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>//OVERFLOW
using namespace std;

//顺序栈
#define STACK_INIT_SIZE 100//存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量
#define ERROR  0
#define OK 1
#define TRUE    1
#define FALSE   0
//typedef  int SElemType;//可以为int,char,……
typedef char SElemType;
typedef char Status;
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;//当前已分配的存储空间
}SqStack;

Status InitStack(SqStack &S);
Status DestroyStack(SqStack &S);
Status ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
Status StackTraverse(SqStack S, Status(*visit)());

//构造一个空栈S
Status InitStack(SqStack &S) {
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(char));
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack &S){
    if(S.base ){
        free(S.base);
        S.base = NULL;
        S.top = NULL;
        S.stacksize = 0;
    }
    return OK;
}


Status ClearStack(SqStack &S){
    if(S.base){
        S.top = S.base;
    }
    return OK;
}

//判断栈是否为空
Status StackEmpty(SqStack S) {
    if (S.top == S.base) return OK;
    else return ERROR;
}

int StackLength(SqStack S)
{
    return (S.top-S.base)/sizeof(SElemType);
}


//若栈不空，则用e返回栈顶元素，并返回ok(1),否则返回error(0)
Status GetTop(SqStack S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {//栈满，追加存储空间
        S.base = (SElemType*)realloc(S.base,
                                     (S.stacksize + STACKINCREMENT) * sizeof(char));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *(S.top++) = e;
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回ok,否则返回error
Status Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(--S.top);
    return OK;
}

Status StackTraverse(SqStack S, Status(* visit)(SElemType)){
    while(S.top > S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}

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


//打印栈元素
void PrintStack(SqStack s) {
    if (StackEmpty(s)) return;
    printf("Stack:");
    while (!StackEmpty(s)){
        printf("%c ", *(s.top - 1));
        SElemType e;
        Pop(s, e);
    }
    printf("\n");
}

void matchStr(){
    SqStack s;
    SElemType ch[80], *p, e;
    if(InitStack(s)){
        printf("请输入表达式:\n");
        gets(ch);
        p=ch;
        while(*p){ // 没到串尾
            switch(*p){
                case '(':
                case '[':
                case '{':
                    Push(s,*p++);
                    break;
                case ')':
                case ']':
                case '}':
                    if(!StackEmpty(s)) {
                        Pop(s,e);
                        // 弹出的栈顶元素与*p不配对
                        if((*p==')' && e!='(' )|| (*p==']'&& e!='[') ||(*p=='}' && e!='{')){
                            printf("左右括号不配对，匹配失败！\n");
                            exit(ERROR);
                        }
                        else p++;
                    } else {// 栈空
                        printf("缺乏左括号,匹配失败！\n");
                        exit(ERROR);
                    }
                    break;
                default:
                    p++; // 其它字符不处理，指针向后移
            }
        }
        //字符串结束时栈空
        if(StackEmpty(s))
            printf("括号匹配成功！\n");
        else
            printf("缺乏右括号，匹配失败！\n");
    }
}

int main() {
    matchStr();  //SElemtype = char;
    //conversion();
    return 0;
}



()[{458(0-{}[])}]

行编辑程序

#pragma warning(disable:4996)
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>//OVERFLOW
using namespace std;

//顺序栈
#define STACK_INIT_SIZE 100//存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量
#define ERROR  0
#define OK 1
#define TRUE    1
#define FALSE   0
//typedef  int SElemType;//可以为int,char,……
typedef char SElemType;
typedef char Status;
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;//当前已分配的存储空间
}SqStack;

Status InitStack(SqStack &S);
Status DestroyStack(SqStack &S);
Status ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
Status StackTraverse(SqStack S, Status(*visit)());

//构造一个空栈S
Status InitStack(SqStack &S) {
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(char));
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack &S){
    if(S.base ){
        free(S.base);
        S.base = NULL;
        S.top = NULL;
        S.stacksize = 0;
    }
    return OK;
}


Status ClearStack(SqStack &S){
    if(S.base){
        S.top = S.base;
    }
    return OK;
}

//判断栈是否为空
Status StackEmpty(SqStack S) {
    if (S.top == S.base) return OK;
    else return ERROR;
}

int StackLength(SqStack S)
{
    return (S.top-S.base)/sizeof(SElemType);
}

//若栈不空，则用e返回栈顶元素，并返回ok(1),否则返回error(0)
Status GetTop(SqStack S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {//栈满，追加存储空间
        S.base = (SElemType*)realloc(S.base,
                                     (S.stacksize + STACKINCREMENT) * sizeof(char));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *(S.top++) = e;
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回ok,否则返回error
Status Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(--S.top);
    return OK;
}

Status StackTraverse(SqStack S, Status(* visit)(SElemType)){
    while(S.top > S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}

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

//打印栈元素
void PrintStack(SqStack s) {
    if (StackEmpty(s)) return;
    printf("Stack:");
    while (!StackEmpty(s)){
        printf("%c ", *(s.top - 1));
        SElemType e;
        Pop(s, e);
    }
    printf("\n");
}

void LineEdit(){
    SqStack S;
    InitStack(S);
    SElemType ch,c;
    while((ch=getchar())!=EOF){
        while(ch!=EOF && ch!='\n'){
            switch(ch){
                case '#':
                    Pop(S, c);
                    break;
                case '@':
                    ClearStack(S);
                    break;
                default:
                    Push(S, ch);
                    break;
            }
            ch=getchar();
        }
        StackTraverse(S, visit);
        ClearStack(S);
        if(ch!=EOF) ch=getchar();
    }
    DestroyStack(S);
}

int main() {
    LineEdit();
    return 0;
}

  whli##ilr#e(a#*s)
  			outcha@putchar(*s=#++)

表达式转换

#pragma warning(disable:4996)
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>//OVERFLOW
using namespace std;

//顺序栈
#define STACK_INIT_SIZE 100//存储空间初始分配量
#define STACKINCREMENT 10//存储空间分配增量
#define ERROR  0
#define OK 1
#define TRUE    1
#define FALSE   0
//typedef  int SElemType;//可以为int,char,……
typedef int SElemType;
typedef int Status;
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;//当前已分配的存储空间
}SqStack;

Status InitStack(SqStack &S);
Status DestroyStack(SqStack &S);
Status ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
Status StackTraverse(SqStack S, Status(*visit)());

//构造一个空栈S
Status InitStack(SqStack &S) {
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(char));
    if (!S.base) exit(OVERFLOW);
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack &S){
    if(S.base ){
        free(S.base);
        S.base = NULL;
        S.top = NULL;
        S.stacksize = 0;
    }
    return OK;
}


Status ClearStack(SqStack &S){
    if(S.base){
        S.top = S.base;
    }
    return OK;
}

//判断栈是否为空
Status StackEmpty(SqStack S) {
    if (S.top == S.base) return OK;
    else return ERROR;
}

int StackLength(SqStack S)
{
    return (S.top-S.base)/sizeof(SElemType);
}
//若栈不空，则用e返回栈顶元素，并返回ok(1),否则返回error(0)
Status GetTop(SqStack S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(SqStack &S, SElemType e) {
    if (S.top - S.base >= S.stacksize) {//栈满，追加存储空间
        S.base = (SElemType*)realloc(S.base,
                                     (S.stacksize + STACKINCREMENT) * sizeof(char));
        if (!S.base) exit(OVERFLOW);//存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    *(S.top++) = e;
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回ok,否则返回error
Status Pop(SqStack &S, SElemType &e) {
    if (S.top == S.base) return ERROR;
    e = *(--S.top);
    return OK;
}

Status StackTraverse(SqStack S, Status(* visit)(SElemType)){
    while(S.top > S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}

Status visit(SElemType e){
    printf("%c ", e);
    return OK;
}
//打印栈元素
void PrintStack(SqStack s) {
    if (StackEmpty(s)) return;
    printf("Stack:");
    while (!StackEmpty(s)){
        printf("%c ", *(s.top - 1));
        SElemType e;
        Pop(s, e);
    }
    printf("\n");
}

int EvaluateExpression();

char OP[7] = {'+', '-', '*', '/', '(', ')','#'};
int main(){
    printf("Expression =  %d\n",EvaluateExpression());
    return 0;
}

//判断c是否再OP中
Status In(char c, char* OP){
    for(unsigned int i = 0 ; i < strlen(OP);  ++i){
        if(*(OP + i) == c) return TRUE;
    }
    return FALSE;
}

//返回优先级情况
char Precede(char a, char b){
    int i,j;
    //优先级表
    char pre[][7]={
        {'>','>','<','<','<','>','>'},
        {'>','>','<','<','<','>','>'},
        {'>','>','>','>','<','>','>'},
        {'>','>','>','>','<','>','>'},
        {'<','<','<','<','<','=',' '},
        {'>','>','>','>',' ','>','>'},
        {'<','<','<','<','<',' ','='}};
    switch(a){
        case '+': i = 0; break;
        case '-': i = 1; break;
        case '*': i = 2; break;
        case '/': i = 3; break;
        case '(': i = 4; break;
        case ')': i = 5; break;
        case '#': i = 6; break;
    }
    switch(b){
        case '+': j = 0; break;
        case '-': j = 1; break;
        case '*': j = 2; break;
        case '/': j = 3; break;
        case '(': j = 4; break;
        case ')': j = 5; break;
        case '#': j = 6; break;
    }
    return pre[i][j];
}

//二元运算
int Operate(int a, char op, int b){
    int result;
    switch(op){
        case '+': result = a + b; break;
        case '-': result = a - b; break;
        case '*': result = a * b; break;
        case '/': result = a / b; break;
    }
    return result;
}

//跳过空格读取字符
char getcharwithoutspace(){
    char c;
    while((c=getchar())==' ');
    return c;
}

int EvaluateExpression(){
    //定义两种类型的栈
    SqStack OPND;
    SqStack OPTR;
    InitStack(OPTR);
    InitStack(OPND);
    //'#'作为栈底元素
    Push(OPTR, '#');
    //输入
    char c = getcharwithoutspace();
    //获得栈顶元素
    SElemType e;
    GetTop(OPTR, e);
    //进行运算直至读取到#且栈内无其余操作符后退出
    while((c != '#') || (e != '#')){
        //若不是运算符，则入栈
        if(!In(c, OP)){
            int n = 0;
            do{
                //输入的字符 -> 数字
                n = n * 10 + (c - '0');
                c = getcharwithoutspace();
            }while(!In(c, OP));
            Push(OPND, n);
        }else{
            //如果输入的是运算符，则和栈顶的运算符比较优先级
            GetTop(OPTR, e);
            switch(Precede(e, c)){
                    //栈顶元素优先级低
                case '<':
                    Push(OPTR, c);
                    c = getcharwithoutspace();
                    break;
                    //脱去括号并接受下一个字符
                case '=':
                    Pop(OPTR, e);
                    c = getcharwithoutspace();
                    break;
                    //退栈并将运算结果入栈
                case '>':
                    SElemType theta;
                    int b, a;
                    Pop(OPTR, theta);
                    Pop(OPND, b);
                    Pop(OPND, a);
                    Push(OPND, Operate(a, theta, b));
                    break;
                    /*test
                     default:
                     printf("??????");
                     break;
                     */
            }
        }
        //获取栈顶运算符
        GetTop(OPTR, e);
    }
    int result;
    //获取结果
    GetTop(OPND, result);
    return result;
}

4+2*3-10/5#
Expression =  8
孤舟独钓寒江雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构-栈的应用
Junds0的博客
05-07 2047
第1关：利用栈实现整数的十进制转八进制 本关任务：基于栈stack数据结构解决整数十进制转八进制的问题。 第2关：利用栈判断字符串括号是否匹配 本关任务：基于栈stack数据结构判断字符串中的括号是否匹配，字符串中仅包含如下字符：( ) [ ] { }。 第3关：利用栈判断字符串是否为回文串 本关任务：基于栈stack数据结构判断字符串是否为“回文串”。 第4关：栈之巩固练习 第1题 标准答案：B C 第2题 标准答案：B 第3题 标准答案：C 对于A选项：可能的顺序是A入栈，A出栈，B入栈，B出
数据结构-栈基本运算的实现及其应用
Junds0的博客
10-09 1432
本关任务：实现顺序栈的入栈、出栈和取栈顶功能。 第2关：链栈的实现 本关任务：实现链栈的入栈、出栈和取栈顶功能。 第3关：利用栈实现数制转换 本关任务：利用栈将一个十进制整数N转换成其它进制数。顺序栈的初始化：构造一个空栈。具体操作函数定义如下： void SS_Initiate(SqStack &S)判断顺序栈是否为空：若为空栈，则返回true,否则返回false。该操作函数具体定义如下： bool SS_IsEmpty(SqStack S)判断顺序栈是否已满：若顺序栈达到最大长度，则返回 true,否则
数据结构——栈的应用举例
程序员的修养
02-27 694
本文所有代码均为伪码，仅阐述算法基本思想——《数据结构》清华大学出版社 - 算法1 对于输入的任意一个非负十进制整数，打印输出与其等值的N进制数 #define N 8 // 定义待转换的进制N(2～9) typedef int SElemType; // 定义栈元素类型为整型 void conversion() { SqStack s; unsigned n; /
数据结构之栈的操作
niannianxi的博客
11-08 414
栈实际上就是满足先进后出的性质的数学或数据结构（这里可以想象成枪的结构：先压入弹夹的子弹反而最后射出去），下面让我们学习一下栈的相关操作： 1.栈的宏定义： #define STACK_INIT_SIZE 100 //栈初始化的存储空间 #define STACKINCREMENT 10 //栈溢出后增加空间（每次增加10个） 2.定义栈的结构体以及改名： typedef char ElemType; typedef struct { ElemType *base;//栈顶 ElemT
数据结构-栈及栈的应用
初始化的博客
07-19 4495
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
数据结构——栈的详解
热门推荐
晴空๓
04-20 7万+
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。 C语言和C++中的栈C语言中的栈栈的定义C语言中栈的基本操作栈的初始化判断是否为空栈判断是否为满栈入栈出栈C语言实现栈的具体代码C++中的栈C++中栈的基...
数据结构6.1-栈的应用之括号匹配
m0_62035627的博客
05-09 1458
括号匹配是数据结构中比较常见的应用之一，其算法思路如下： ①顺序遍历给定test的每一个字符 ②对于除了括号之外的无关字符直接跳过 ③遇到开括号就压入栈 ④遇到闭括号就弹出当时的栈顶元素与之匹配 ⑤如果匹配成功则继续，如果不匹配则以失败结束 由于括号匹配大部分代码与栈的基础操作相同，下面只展示核心代码： 1.括号匹配 bool bracketMatching(char* paraString, int paraLength) { int i; // 第一步：通过压入‘#’到.
java数据结构-栈
小赵的呢
02-18 6226
栈 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的常见基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：判断一个栈是否为空，若栈为空则返回t
数据结构——栈的应用
m0_57484470的博客
10-23 3192
本文采用C语言具体实现栈结构的经典应用样例：数制转换，括号匹配，行编辑程序，表达式求值问题。
数据结构学习--栈及其应用
06-25
栈和对列是两种操作特殊的线性表，在实际中应用相当广泛。本实验的目的在于使学生 深入理解栈的特性，熟悉栈的基本操作，以便在实际问题背景下灵活运用它们，同时巩固对 这种结构的构造方法和掌握其运行过程，了解较...
数据结构-栈的应用：顺序栈与链栈的应用
03-22
数据结构-栈的应用：顺序栈与链栈的应用
数据结构-栈和队列-PPT
02-04
数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与线性表相同，仍为一对一关系。栈...
数据结构-栈10
01-20
（1）栈中的数据元素遵守”先进后出”(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。  栈在计算机中应用相当广泛，包括递归的调用和返回、二叉树和森林的遍历、调用子程序及...
数据结构-栈的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 栈的部分实现代码（栈的实现、栈的应用），详细介绍参考数据结构--栈的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
C语言-数据结构-栈-实验报告
m0_46566665的博客
12-23 6715
实验报告内容： 一、实验目的、要求： （1）熟练掌握栈的特点(先进后出FILO)及基本操作，如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。 （2）编写适当的主函数和相关函数，使实验题目运行出正确结果。 （3）当场编程、调试、编译。 （4）程序具有一定的健壮性、可读性，尽量简洁。 （5）程序运行完成后分别存盘，上交实验报告，要求写出实验体会 二、实验内容： （1）实验题目 （2）主要函数的算法设计思想 （3）程序清单 （3）测试数据、实验结果及结论 （4）实验体会（实验中存在的
操作系统期末复习笔记！
06-13
操作系统期末复习笔记
pyzmq-22.0.0-cp38-cp38-manylinux2010_i686.whl
06-13
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
pyzmq-25.1.1b2-cp37-cp37m-win_amd64.whl
最新发布
06-13
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
头歌数据结构-栈的应用
07-27
栈是一种常见的数据结构，其特点是后进先出（Last In First Out，简称LIFO）。 栈的应用非常广泛，以下是几个常见的栈的应用场景： 1. 括号匹配：栈可以用于检验表达式中的括号是否匹配。遍历表达式，当遇到左括号时，将其入栈；当遇到右括号时，与栈顶元素进行匹配，如果匹配成功则出栈，否则表达式不合法。 2. 函数调用：在函数调用过程中，函数的局部变量、返回地址等信息需要被保存。栈可以用于存储函数调用的上下文信息，在函数调用结束后，通过出栈操作恢复上一层函数的执行状态。 3. 表达式求值：栈可以用于实现表达式的求值。通过将中缀表达式转换为后缀表达式，并利用栈进行运算符和操作数的计算。 4. 浏览器的前进后退：浏览器的前进和后退功能可以使用两个栈来实现。当前页面访问时，将页面URL入栈A；当点击后退按钮时，将栈A的元素出栈并入栈B；当点击前进按钮时，将栈B的元素出栈并入栈A。 5. 撤销操作：在编辑器或者图形处理软件中，撤销操作是常见的功能之一。栈可以用于保存操作历史，每次撤销时，将最近的操作出栈即可。 这些只是栈的一些常见应用，实际上栈还可以用于其他许多场景。希望以上内容对您有所帮助！如果您还有其他问题，可以继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值