数据结构：栈「详解」

已于 2023-03-31 17:17:26 修改
阅读量1.4w 收藏 359
点赞数 71
分类专栏： # 数据结构 文章标签： c++ 数据结构 算法 经验分享 笔记
于 2023-03-31 17:13:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56433857/article/details/129877993
版权

目录

 

一，栈的定义

二，栈的基本操作

1，顺序栈

1.1顺序栈的基本概念

1.2顺序栈的基本操作

2，链栈

2.1链栈的基本概念

2.2链栈的种类

2.3链栈的基本操作

三，栈的应用

1，函数递归调用

2，表达式求值

3，数制转换

4，迷宫求解

参考资料

 

一，栈的定义

栈（Stack）是一种常见的数据结构，它是一种“后进先出”（Last In First Out，LIFO）的数据结构。栈可以看做是一种特殊的线性表，只能在栈顶进行插入和删除操作。栈顶是允许操作的，而栈底是固定的。

二，栈的基本操作

栈的基本操作包括：入栈（Push）、出栈（Pop）、取栈顶元素（Top）和判空（IsEmpty）等。

1，顺序栈

        1.1顺序栈的基本概念

顺序栈是一种使用数组实现的栈，也称为数组栈。其基本思路是通过数组来存储栈中的元素，并通过栈顶指针指示栈顶元素在数组中的位置。顺序栈具有以下特点：

  1. 存储结构：使用数组作为底层存储结构，数组的每个元素存储栈中的一个元素；
  2. 操作受限：栈只能从栈顶插入和删除元素，不支持在栈中间插入和删除元素；
  3. 先进后出：栈的元素遵循“先进后出”（Last In First Out, LIFO）的原则，即后插入的元素先被删除；
  4. 顺序访问：只能从栈顶开始访问栈中的元素，不能从栈底或中间位置访问元素。

顺序栈的实现非常简单，可以使用数组和栈顶指针两个变量来实现。顺序栈的主要操作包括初始化、入栈、出栈、获取栈顶元素、判断栈是否为空以及获取栈中元素的数量等。由于顺序栈的存储结构是数组，因此在使用过程中需要考虑数组大小的限制，当栈中元素数量超过数组大小时，需要对数组进行扩容。

 

注意：除了遍历栈中的元素的操作时间复杂度为O(n)外，其余：入栈、出栈、取栈顶元素、判断栈是否为空操作的时间复杂度均为O(1)。

83a5960b9b2a45e09a5f1a4efa2c61f5.png

         1.2顺序栈的基本操作

相关的头文件

#include<math.h>
#include <iostream>
typedef int SElemType;
#define STACK_INIT_SIZE 10 //存储空间初始分配量
#define STACK_INCREMENT 2  //存储空间分配增量

定义顺序栈结构体

struct SqStack{ //定义顺序栈结构体
    SElemType *base; //栈底指针
    SElemType *top;  //栈顶指针
    int stacksize;   //栈可用的最大容量
};

初始化栈

void InitStack(SqStack &S){ //初始化栈S
    S.base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType)); //给栈分配空间
    if(!S.base) //如果分配失败
        exit(OVERFLOW); //则退出程序
    S.top = S.base; //栈顶指针和栈底指针指向同一个位置
    S.stacksize = STACK_INIT_SIZE; //初始化栈的最大容量
}

销毁栈

void DestoryStack(SqStack &S){ //销毁栈S
    free(S.base); //释放栈S占用的空间
    S.top = S.base = NULL; //将栈底指针和栈顶指针都置为空
    S.stacksize = 0; //将栈的最大容量清零
}

清空栈

void ClearStack(SqStack &S){ //清空栈S
    S.top = S.base; //将栈顶指针指向栈底指针，实现清空栈的效果
}

判断栈是否为空

int StackEmpty(SqStack S){ //判断栈S是否为空
    if(S.top == S.base) //如果栈顶指针和栈底指针指向同一个位置，说明栈为空
        return true;
    else
        return false;
}

返回栈长度

int StackLength(SqStack S){ //求栈S的长度
    return S.top - S.base; //栈顶指针减去栈底指针的差即为栈的长度
}

获取栈顶元素值

int GetTop(SqStack S,SElemType &e){ //获取栈顶元素，并将其存储到e中
    if (S.top > S.base){ //如果栈不为空
        e = *(S.top-1); //将栈顶元素存储到e中
        return true;
    }
    else
        return false;
}

入栈

void Push(SqStack &S,SElemType e){ //在栈顶插入元素e
    if(S.top - S.base == S.stacksize){ //如果栈满
        S.base = (SElemType*)realloc(S.base, (S.stacksize+STACK_INCREMENT)*sizeof(SElemType)); //给栈扩容
        if(!S.base) //如果扩容失败
            exit(OVERFLOW); //则退出程序
        S.top = S.base + S.stacksize; //将栈顶指针指向扩容后的栈顶
        S.stacksize += STACK_INCREMENT; //更新栈的最大容量
    }
    *(S.top)++ = e; //将元素e插入栈顶，并将栈顶指针上移一位
}

出栈

// 如果栈为空，返回false；否则返回true
int Pop(SqStack &S,SElemType &e){
    if(S.top == S.base) //栈空
        return false;
    e = *(--S.top); //将栈顶元素赋给e，栈顶指针下移一个存储单元
    return true;
}

遍历打印栈内元素

// 定义一个函数visit，用于打印元素
void visit(SElemType e)
{
    std::cout << e << " ";
}

// 定义一个函数用于遍历栈中的元素并对每个元素执行visit函数
void StackTraverse(SqStack S,void(*visit)(SElemType)){
    SElemType *p = S.base;
    while(S.top > p) //p指向栈元素
        visit(*p++); //对该栈调用visit()，p指针上移一个存储单元
    printf("\n");
}

主函数

int main() {
    int j;
    SqStack s;
    SElemType e;
    InitStack(s);
    for(j = 1; j <= 12; j++)
        Push(s, j);
    printf("栈中元素依次为\n");
    StackTraverse(s, visit);
    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));
    DestoryStack(s);
    printf("销毁栈后，s.top = %u,s.base = %u,s.stacksize = %d\n",s.top,s.base,s.stacksize);
}

2，链栈

        2.1链栈的基本概念

链栈是一种基于链表实现的栈，其特点是无需事先分配固定长度的存储空间，栈的长度可以动态增长或缩小，避免了顺序栈可能存在的空间浪费和存储溢出问题。

 

链栈中的每个元素称为“节点”，每个节点包括两个部分：数据域和指针域。数据域用来存储栈中的元素值，指针域用来指向栈顶元素所在的节点。

 

链栈的基本操作包括入栈、出栈、获取栈顶元素和遍历等，相比顺序栈而言，链栈的实现难度稍高，但其在某些情况下有着更好的灵活性和效率，特别适用于在动态存储空间较为紧缺的场合。

 

链栈的进栈push和出栈pop操作都很简单，时间复杂度均为O(1)

注意：如果栈的使用过程中元素变化不可预料,那么最好使用链栈,反之,如果它的变化在可控范围内,建议使用顺序栈。

 

        2.2链栈的种类

链栈按照链表的实现方式可分为单链栈和双链栈。实际应用通常采用单链栈。

 

单链栈使用单链表实现，每个节点只含有一个指向下一个节点的指针。因此，单链栈只能从栈顶进行插入和删除操作。

6207e36f62044dd19d14b45fa97aa65b.jpeg

双链栈使用双向链表实现，每个节点同时包含指向前一个节点和后一个节点的指针。因此，双链栈既可以从栈顶进行插入和删除操作，也可以从栈底进行插入和删除操作，使得操作更加灵活。

d7b4d20d91614df286c67a462edd10eb.png

         2.3链栈的基本操作

单链栈的类型定义

// 定义链栈的结构体
typedef struct StackNode{
    SElemType data;
    StackNode *next;
}StackNode,*LinkStack;

单链栈初始化

// 初始化链栈
int InitStack(LinkStack &S){
    S = NULL;
    return true;
}

判断单链栈是否为空

// 判断链栈是否为空
bool StackEmpty(LinkStack S){
    return S == NULL;
}

单链栈入栈

b061f28cdb2547af983508b3ce825e1f.png

// 入栈
bool Push(LinkStack &S, SElemType e){
    StackNode *p = (StackNode*)malloc(sizeof(StackNode));
    if(!p){
        return false; // 分配内存失败
    }
    p->data = e;
    p->next = S;
    S = p;
    return true;
}

 单链栈出栈

54ddaf73dee0455fbe163551209806aa.png

// 出栈
bool Pop(LinkStack &S, SElemType &e){
    if(StackEmpty(S)){
        return false; // 栈为空
    }
    StackNode *p = S;
    e = p->data;
    S = S->next;
    free(p);
    return true;
}

获取单链栈栈顶元素

// 获取栈顶元素
bool GetTop(LinkStack S, SElemType &e){
    if(StackEmpty(S)){
        return false; // 栈为空
    }
    e = S->data;
    return true;
}

清空单链栈

// 清空栈
void ClearStack(LinkStack &S){
    StackNode *p;
    while(S){
        p = S;
        S = S->next;
        free(p);
    }
}

销毁单链栈

// 销毁栈
void DestroyStack(LinkStack &S){
    ClearStack(S);
    S = NULL;
}

遍历单链栈

// 遍历栈并打印
void StackTraverse(LinkStack S){
    StackNode *p = S;
    while(p){
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

测试代码

#include <iostream>

int main() {
    LinkStack S;
    InitStack(S);
    int e;
    Push(S, 1);
    Push(S, 2);
    Push(S, 3);
    printf("现在栈内元素为(后进先出)：");
    StackTraverse(S);
    printf("栈顶元素为：%d\n", GetTop(S,e));
    Pop(S,e);
    printf("现在栈内元素为(后进先出)：");
    StackTraverse(S);
    printf("弹出一个元素后，栈顶元素为：%d\n", GetTop(S,e));
    ClearStack(S);
    if (StackEmpty(S)) {
        printf("栈为空\n");
    } else {
        printf("栈不为空\n");
    }
    DestroyStack(S);
    return 0;
}

三，栈的应用

1，函数递归调用

函数递归调用时，计算机会把函数调用时需要的参数和返回地址等信息放入栈中，函数执行完毕后再从栈中取回这些信息。

//以汉诺塔问题为例展示栈的递归调用
#include <iostream>

int c = 0;
void move(char x,int n,char z){
    printf("第%i步:将%i号盘从%c移到%c\n", ++c, n, x, z);
}

void hanoi(int n, char x, char y, char z){
    if(n==1){
        move(x, 1, z);
    }
    else{
        hanoi(n-1, x, z, y);
        move(x, n, z);
        hanoi(n-1, y, x, z);
    }
}

int main() {
    int n;
    printf("三个塔座为a,b,c,圆盘最初在a座，借助b座移到c座，请输入圆盘数量：");
    scanf("%d",&n);
    hanoi(n, 'a', 'b', 'c');
}

f997e7d8fe02427b8181d35c1f7470b7.jpeg

f5af104ab83446a3a8bf721f95b7cd26.png

2，表达式求值

在编译器中，中缀表达式转为后缀表达式后，可以使用栈来实现后缀表达式的求值。

char Precede(SElemType t1, SElemType t2)
{ 
  char f;
  switch(t2)
  { case '+':
    case '-': if(t1=='(' || t1=='\n')
                f='<'; 
              else
                f='>'; 
              break;
    case '*':
    case '/': if(t1=='*' || t1=='/' || t1==')')
                f='>'; 
              else
                f='<'; 
              break;
    case '(': if(t1==')')
              { printf("括号不匹配\n");
                exit(OVERFLOW);
              }
              else
                f='<'; 
              break;
    case ')': switch(t1)
              { case '(': f='='; 
                          break;
                case'\n': printf("缺乏左括号\n");
                          exit(OVERFLOW);
                default : f='>'; 
              }
              break;
    case'\n': switch(t1)
              { case'\n': f='='; 
                          break;
                case '(': printf("缺乏右括号\n");
                          exit(OVERFLOW);
                default : f='>'; 
              }
  }
  return f;
}
Status In(SElemType c)
{ 
  switch(c)
  { case '+':
    case '-':
    case '*':
    case '/':
    case '(':
    case ')':
    case'\n': return TRUE;
    default : return FALSE;
  }
}
SElemType Operate(SElemType a, SElemType theta, SElemType b)
{ 
  switch(theta)
  { case '+': return a+b;
    case '-': return a-b;
    case '*': return a*b;
  }
  return a/b; 
}


//  表达式求值（范围为int类型，输入负数要用（0-正数）表示）
typedef int SElemType; 
SElemType EvaluateExpression()
{ 
  SqStack OPTR, OPND;
  SElemType a, b, d, x; 
  char c; 
  c=getchar(); 
  InitStack(OPTR); 
  InitStack(OPND);
  Push(OPTR, '\n'); 
  GetTop(OPTR, x); 
  while(c!='\n' || x!='\n') 
  { if(In(c)) 
      switch(Precede(x, c)) 
      { case'<': Push(OPTR, c); 
                 c=getchar(); 
                 break;
        case'=': Pop(OPTR, x); 
                 c=getchar(); 
                 break;
        case'>': Pop(OPTR, x); 
                 Pop(OPND, b); 
                 Pop(OPND, a);
                 Push(OPND, Operate(a, x, b)); 
      }
    else if(c>='0' && c<='9') 
    { d=0;
      while(c>='0' && c<='9') 
      { d=d*10+c-'0';
        c=getchar();
      }
      Push(OPND, d); 
    }
    else 
    { printf("出现非法字符\n");
      DestroyStack(OPTR);
      DestroyStack(OPND);
      exit(OVERFLOW);
    }
    GetTop(OPTR, x); 
  }
  Pop(OPND, x); 
  if(!StackEmpty(OPND)) 
  { printf("表达式不正确\n");
    DestroyStack(OPTR);
    DestroyStack(OPND);
    exit(OVERFLOW);
  }
  DestroyStack(OPTR);
  DestroyStack(OPND);
  return x;
}
void main()
{
  printf("请输入算术表达式，负数要用（0-正数）表示\n");
  printf("%d\n", EvaluateExpression());
}

3，数制转换

可以使用栈来进行二进制和十进制等进制之间的转换

#define N 8 
typedef int SElemType; 

void conversion() 
{ 
  SqStack s;
  unsigned n; 
  SElemType e;
  InitStack(s); 
  printf("将十进制整数n转换为%d进制数，请输入：n（≥0）=", N);
  scanf("%u", &n); 
  while(n) 
  { Push(s, n%N); 
    n=n/N;
  }
  while(!StackEmpty(s)) 
  { Pop(s, e); 
    printf("%d", e); 
  }
  printf("\n");
}
void main()
{
  conversion();
}

4，迷宫求解

在迷宫求解中，可以使用栈来实现深度优先搜索算法。

// 利用栈求解迷宫问题（只输出一个解）
struct PosType 
{ int x; 
  int y; 
};
// 全局变量
PosType begin, end; 
PosType direc[4]={{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
// {行增量, 列增量}，移动方向依次为东南西北
#define MAXLENGTH 25 
typedef int MazeType[MAXLENGTH][MAXLENGTH]; 
MazeType m; 
int x, y; 
void Print()
{ 
  int i, j;
  for(i=0; i<x; i++)
  { for(j=0; j<y; j++)
      printf("%3d", m[i][j]);
    printf("\n");
  }
}
void Init()
{ 
  int i, j, x1, y1;
  printf("请输入迷宫的行数,列数（包括外墙）：");
  scanf("%d,%d", &x, &y);

  for(i=0; i<y; i++) 
  { m[0][i]=0; 
    m[x-1][i]=0; 
  }
  for(i=1; i<x-1; i++)
  { m[i][0]=0; 
    m[i][y-1]=0; 
  }
  for(i=1; i<x-1; i++)
    for(j=1; j<y-1; j++)
      m[i][j]=1; 
  printf("请输入迷宫内墙单元数：");
  scanf("%d", &j);
  printf("请依次输入迷宫内墙每个单元的行数,列数：\n");
  for(i=1; i<=j; i++)
  { scanf("%d,%d", &x1, &y1);
    m[x1][y1]=0; 
  }
  printf("迷宫结构如下：\n");
  Print();
  printf("请输入入口的行数,列数：");
  scanf("%d,%d", &begin.x, &begin.y);
  printf("请输入出口的行数,列数：");
  scanf("%d,%d", &end.x, &end.y);
}
int curstep=1; 
struct SElemType 
{ int ord; 
  PosType seat; 
  int di; 
};


// 定义墙元素值为0，可通过路径为1，经试探不可通过路径为-1，通过路径为足迹
Status Pass(PosType b)
{ 
  if(m[b.x][b.y]==1)
    return OK;
  else
    return ERROR;
}
void FootPrint(PosType b)
{ 
  m[b.x][b.y]=curstep;
}
void NextPos(PosType &b, int di)
{ 

  b.x+=direc[di].x;
  b.y+=direc[di].y;
}
void MarkPrint(PosType b)
{ 
  m[b.x][b.y]=-1;
}
Status MazePath(PosType start, PosType end) 
{ 
  
  PosType curpos=start; 
  SqStack S; 
  SElemType e; 
  InitStack(S); 
  do
  { if(Pass(curpos)) 
    { FootPrint(curpos); 
      e.ord=curstep; 
      e.seat=curpos; 
      e.di=0; 
      Push(S, e); 
      curstep++; 
      if(curpos.x==end.x && curpos.y==end.y) 
        return TRUE;
      NextPos(curpos, e.di); 
    }
    else 
    { if(!StackEmpty(S)) 
      { Pop(S, e); 
        curstep--; 
        while(e.di==3 && !StackEmpty(S)) 
        { MarkPrint(e.seat); 
          Pop(S, e); 
          curstep--; 
        }
        if(e.di<3) 
        { e.di++; 
          Push(S, e); 
          curstep++; 
          curpos=e.seat; 
          NextPos(curpos,e.di);
        }
      }
    }
  }while(!StackEmpty(S));
  return FALSE;
}
void main()
{
  Init(); 
  if(MazePath(begin, end)) 
  { printf("此迷宫从入口到出口的一条路径如下：\n");
    Print(); 
  }
  else
    printf("此迷宫没有从入口到出口的路径\n");
}

 

参考资料

  1. 严蔚敏、吴伟民：《数据结构（C语言版）》
  2. 高一凡：《数据结构算法解析》
  3. 程杰：《大话数据结构》
  4. 王道论坛：《数据结构考研复习指导》

 

林上奇数
关注
专栏目录
数据结构之——栈
WenJieya的博客
03-27 7142
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
【数据结构】栈
knous
03-25 994
栈的概念及结构 如何实现栈 栈的几道练习题
数据结构--栈
最新发布
weixin_62008675的博客
09-05 1662
一些，顺序栈是通过指针指向假设的栈顶，其他元素其实依然存在，但链栈的栈顶之前的元素会被垃圾回收，因此链栈的实现综合时间和空间来看，更优秀一些。对比链栈和顺序栈的实现，可以发现入栈和出战方法的时间复杂度都是O(1)，效率上没有区别，但是顺序栈占用的空间会相对更多。顺序栈底层是数组，最大空间容量受到限制，因此必须初始化一个数组的容量，也就是栈的容量，链栈则无需此操作。常见的栈实现方式有数组和链表两种，其中数组实现的栈又称为顺序栈，链表实现的栈称为链式栈。（Bottom）：固定的，不允许进行插入和删除的另一端。
数据结构与算法（3）栈
flyersboy的博客
04-22 755
栈 1、栈的一个实际需求 请输入一个表达式：7x2x2-5+1-5+3-3 2、栈的介绍 栈的英文为stack 栈是一个**先入后出(FILO-First In Last Out) **的有序列表 栈(stack) 是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端，为变化的一端，称为栈顶(Top) ，另一端为固定的一端，称为栈底(Bottom) 根据栈的定义可知 ，最先放入栈中元素在栈底 ，最后放入的元素在栈顶 删除元素刚好相反 ，最后
什么是栈？
02-11 305
本文将介绍一个重要的数据结构—栈，和之前讲到的链表、数组一样也是一种数据呈线性排列的数据结构，不过在这种结构中，我们只能访问最新添加的数据。栈就像是一摞书，拿到新书时我们会把它放在书堆的最上面，取书时也只能从最上面的新书开始取。 栈 如上就是栈的概念图，现在存储在栈中的只有数据 Blue。往栈中添加数据的时候，新数据被放在最上面。 然后，我们往栈中添加了数据 Green。往栈中添加数据的操作叫作入栈。 接下来，数据 Red 入栈。 从栈中取出数据时，是从最上面，也就是最新的数据开始取出的，...
数据结构(三)--栈
weixin_30251829的博客
12-21 129
数据结构(三)--栈 通常程序开发中内存管理是非常重要的，而内存主要分为占内存和堆内存。那么栈和堆内存有什么区别呢？希望在这篇文章里能带你找到答案！ 1. 栈和堆的引入 在一个简单的程序中我们定义和声明几个基本类型的变量、结构体和数组，先来直观看一下栈和堆的不同： 静态变量 和 局部变量是以压栈出栈的方式分配内存的，系统会在一个代码段中分配和回收局部...
数据结构 栈
yz18931904的博客
05-30 212
/** * 基于数组实现的顺序栈 * @param &lt;E&gt; */ public class Stack&lt;E&gt; { private Object[] data = null; private int maxSize=0; //栈容量 private int top =-1; //栈顶指针 /** * 构造函数：根...
数据结构-栈
m0_61433144的博客
07-20 865
栈是一种特殊的线性表，其只允许在固定一端进行插入和删除操作。允许进行数据插入和删除的一端叫做栈顶，而不允许数据插入和删除的那一端叫做栈底。如上图所示，n1为栈底元素，n5为栈顶元素。由于栈只能在栈顶进行插入删除操作，所以压栈的次序依次为n1，n2，n3，n4，n5；而出栈的次序为n5，n4，n3，n2，n1；由此可见，栈的特性可以概括为后进先出（LastInFirstOut,LIFO）。.........
C语言实现数据结构：栈和队列操作详解
资源摘要信息: 本文档详细介绍了数据结构中栈和队列的概念、操作及C语言实现。栈是一种后进先出（LIFO）的数据结构，支持两种主要操作：push（入栈）和pop（出栈），以及辅助操作如获取栈顶元素和打印栈内容。队列是...
数据结构：栈与队列解题与概念详解
在《数据结构》的学习中，栈和队列作为重要的线性数据结构，被广泛应用于计算机算法和编程中。本章节主要考察了这两个概念的理解和应用。首先，我们来解析题目中提到的知识点： 1. 线性结构的特性：栈和队列都是...
数据结构：栈与队列详解及其应用
在数据结构的学习中，第3章专门探讨了两种重要的数据结构——栈和队列。栈和队列是线性表的特殊形式，它们在逻辑结构上与普通线性表一致，但因为其运算受到特定限制，通常被称为运算受限的线性表。栈的特点是遵循...
Java数据结构：详解及使用场景.pdf
11-18
avaSortedSet<Integer> sortedSet = new TreeSet();sortedSet.add(3);...在实际项目中，根据具体需求选择和组合不同的数据结构，能够有效地处理各种数据和操作，从而实现更高效、更灵活的程序设计。
Java语言实现数据结构栈代码详解
08-28
Java语言实现数据结构栈代码详解 Java语言实现数据结构栈代码详解主要介绍了栈的概念和Java语言实现栈的两种方式：线性栈和链式栈。栈是一种限制插入和删除只能在一个位置上的表，具有“先进后出”的特点。 栈的...
栈数据结构
Jeffxu_lib的博客
08-27 2271
栈是一种先进后出的数据结构，可以分为：顺序栈和链式栈 一、顺序栈 1、其结构如下图所示： 2、栈的基本操作，只有如下的五个 push( ) 入栈 pop( ) 出栈 empty( ) 是否为空 top( ) 返回栈顶元素 size( ) 返回栈中元素个数 swap() 交换 #include<iostream> #include<stack> ...
Linux内核常用数据结构要点
ace_an的专栏
12-22 4026
简单总结一下Linux Kernel常用数据结构和选取原则
数据结构之栈
weixin_30429201的博客
12-07 108
数组、链表、树等数据结构适用于存储数据库应用中的数据记录，它们常常用于记录那些现实世界的对象和活动的数据，便与数据的访问：插入、删除和查找特定数据项而栈和队列更多的是作为程序员的工具来使用。他们主要作为构思算法的辅助工具，而不是完全的数据存储工具。这些数据结构的生命周期比那些数据库类型的结构要短很多。在程序操作执行期间它们才被创建，通常它们去执行某项特殊的任务，当任务完成后就被销毁栈和队列的访...
数据结构——栈
章小幽的博客
07-19 601
class Stack1: def __init__(self): self.items = [] def is_empty(self): return self.items == [] def push(self,item): self.items.append(item) def pop(self): ...
【数据结构】栈（详解）
2201_75425839的博客
05-12 1159
数据结构中的栈（Stack）是一种特殊的线性表，其特殊性在于它只能在一端进行插入和删除操作，这一端被称为栈顶，另一端则被称为栈底。栈遵循“后进先出”（Last In First Out，LIFO）的原则，即最后一个被放入栈中的元素总是第一个被取出。 在编程中，栈常用于实现函数调用、表达式求值、数制转换、迷宫求解等算法。例如，在函数调用中，每调用一个函数，就将该函数的局部变量和返回地址压入调用栈中，当函数返回时，再从调用栈中弹出相应的数据。这种机制确保了函数调用的正确性和顺序性。
栈 详解
qq_43059674的博客
01-20 885
栈的定义       栈（stack）： 是定义仅在表尾进行插入和删除操作的线性表         栈的特性：            (1)把允许插入的一端称为栈顶（top）,对应的另一端称为栈底（bottom） .          (2)如果栈里面不含任何元素那么我们称之为空栈            (3)栈是又称为一种先进后出（Last In First Out）的线性表,简称LI...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林上奇数

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值