数据结构之栈的顺序存储结构及其应用

原创 已于 2022-05-10 17:49:00 修改 · 2.4k 阅读 · 9 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #c语言 #c++
于 2022-05-10 17:02:55 首次发布
本文详细介绍了栈的顺序存储结构，包括初始化、输出、进栈、出栈、获取栈中元素个数等操作，并通过代码实现。接着，展示了栈在括号匹配中的应用，以及如何利用栈进行表达式求值。最后，提供了C++和C语言版本的表达式求值算法，以及对应的样例输出。

文章目录


栈的顺序存储及其应用

这里是数据结构个人学习的笔记记录，如有问题欢迎指正说明

一、栈的顺序存储

栈是仅能在表尾进行插入和删除操作的线性表，遵循先进后出。
栈

先来定义结构体变量，它类似于顺序表，不过结构体中记录长度的变量改为top来记录栈顶，具体定义如下

结构体的定义：

typedef struct CharStack{
    int top;
    int data[MAXSIZE];
}*CharStackPtr;

相关操作实现

1.初始化

定义一个栈，且将此时的top值定义为-1

/* 初始化 */
CharStackPtr charStackInit(){
    CharStackPtr resultPtr=(CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top=-1;

    return resultPtr;
}

2.依次对栈中的每个数据元素输出

void outputStack(CharStackPtr paraStack){
    for(int i=0;i<=paraStack->top;i++)
    {
        printf("%c ",paraStack->data[i]);
    }
    printf("\r\n");
}

3.进栈（push）

改变top值
进栈

void push(CharStackPtr paraStackPtr,int paraValue){
    if(paraStackPtr->top>=MAXSIZE-1){
        printf("Cannot push element:stack full.\r\n");
        return ;
    }
    paraStackPtr->top++;

    paraStackPtr->data[paraStackPtr->top]=paraValue;
}

4.出栈（pop）

char pop(CharStackPtr paraStackPtr){
    if(paraStackPtr->top<0)
    {
        printf("Cannot pop element:stack empty.\r\n");
        return '\0';
    }
    paraStackPtr->top--;

    return paraStackPtr->data[paraStackPtr->top+1];
}

5.栈中元素个数

因为pop记录栈顶元素下标，所以求栈中元素的个数就十分容易了

int stackLength(CharStackPtr paraStackPtr)
{
    return paraStackPtr->top+1;
}

6.具体代码实现

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

#define MAXSIZE 10

typedef struct CharStack{
    int top;
    int data[MAXSIZE];
}*CharStackPtr;

void outputStack(CharStackPtr paraStack){
    for(int i=0;i<=paraStack->top;i++)
    {
        printf("%c ",paraStack->data[i]);
    }
    printf("\r\n");
}

CharStackPtr charStackInit(){
    CharStackPtr resultPtr=(CharStackPtr)malloc(sizeof(struct CharStack));
    resultPtr->top=-1;

    return resultPtr;
}

void push(CharStackPtr paraStackPtr,int paraValue){
    if(paraStackPtr->top>=MAXSIZE-1){
        printf("Cannot push element:stack full.\r\n");
        return ;
    }
    paraStackPtr->top++;

    paraStackPtr->data[paraStackPtr->top]=paraValue;
}

char pop(CharStackPtr paraStackPtr){
    if(paraStackPtr->top<0)
    {
        printf("Cannot pop element:stack empty.\r\n");
        return '\0';
    }
    paraStackPtr->top--;

    return paraStackPtr->data[paraStackPtr->top+1];
}

int stackLength(CharStackPtr paraStackPtr)
{
    return paraStackPtr->top+1;
}

void pushPopTest(){
    char ch;
    printf("---Begin---\r\n");

    CharStackPtr tempStack=charStackInit();
    printf("After initialization,the stack is: ");
    outputStack(tempStack);

    for(ch='a';ch<'m';ch++){
        printf("Pushing %c.\r\n",ch);
        push(tempStack,ch);
        outputStack(tempStack);
    }
    printf("The length of the stack is %d\n",stackLength(tempStack));

    for(int i=0;i<3;i++){
        ch=pop(tempStack);
        printf("Pop %c.\r\n",ch);
        outputStack(tempStack);
    }
    printf("---End---");
}
int main(){
    pushPopTest();
    return 0;
}

7.样例输出

—Begin—
After initialization,the stack is:
Pushing a.
a
Pushing b.
a b
Pushing c.
a b c
Pushing d.
a b c d
Pushing e.
a b c d e
Pushing f.
a b c d e f
Pushing g.
a b c d e f g
Pushing h.
a b c d e f g h
Pushing i.
a b c d e f g h i
Pushing j.
a b c d e f g h i j
Pushing k.
Cannot push element:stack full.
a b c d e f g h i j
Pushing l.
Cannot push element:stack full.
a b c d e f g h i j
The length of the stack is 10
Pop j.
a b c d e f g h i
Pop i.
a b c d e f g h
Pop h.
a b c d e f g
—End—
Finish.

二、栈的应用之括号匹配

1.匹配函数

实现原理：另外生成一个栈，遇到括号的的前半部分则压栈，遇到后半部分就与与新生成的栈的栈顶来匹配，如果不匹配则说明该式子的等号不匹配，直接返回false；否则匹配，继续执行。

bool bracketMatching(char* paraString, int paraLength) {

    CharStackPtr tempStack = charStackInit();
	push(tempStack, '#');
	char tempChar, tempPopedChar;

	for (int i = 0; i < paraLength; i++) {
		tempChar = paraString[i];

		switch (tempChar) {
		case '(':
		case '[':
		case '{':
			push(tempStack, tempChar);
			break;
		case ')':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '(') {
				return false;
			} // Of if
			break;
		case ']':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '[') {
				return false;
			} // Of if
			break;
		case '}':
			tempPopedChar = pop(tempStack);
			if (tempPopedChar != '{') {
				return false;
			} // Of if
			break;
		default:
			// Do nothing.
			break;
		}// Of switch
	} // Of for i

	tempPopedChar = pop(tempStack);
	if (tempPopedChar != '#') {
		return true;
	} // Of if

	return true;
}

2.输出样例

Is the expression ‘[2 + (1 - 3)] * 4’ bracket matching? 1
Is the expression ‘( ) )’ bracket matching? 0
Is the expression ‘()()(())’ bracket matching? 1
Is the expression ‘({}[])’ bracket matching? 1
Is the expression ‘)(’ bracket matching? 0

三、表达式求值

1.C++闵版复刻

#include<iostream>
#include<cstring>
#include<algorithm>
#include<stack>
#include<unordered_map>

using namespace std;

stack<int> num;
stack<char> op;

void eval()
{
    auto b=num.top();
    num.pop();
    auto a=num.top();
    num.pop();
    auto c=op.top();
    op.pop();
    int x;
    if(c=='+')
    x=a+b;
    else if(c=='-')
    x=a-b;
    else if(c=='*')
    x=a*b;
    else 
    x=a/b;
    num.push(x);
}

int main()
{
    unordered_map<char,int> pr{{'+',1},{'-',1},{'*',2},{'/',2}};
    string str;
    cin >> str;
    for(int i=0;i<str.size();i++)
    {
        auto c=str[i];
        if(isdigit(c))
        {
            int x=0,j=i;
            while(j<str.size()&&isdigit(str[j]))
            x=x*10+str[j++]-'0';
            i=j-1;
            num.push(x);
        }else if(c=='(')
        op.push(c);
        else if(c==')')
        {
            while(op.top()!='(')
            eval();
        }else{
            while(op.size()&&op.top()!='('&&pr[op.top()]>=pr[c])
            eval();
            op.push(c);
        }
    }
    while(op.size())
    eval();
    cout << num.top()<<endl;
    return 0;
}

2.C版

实现思路：

(一)中缀表达式 －> 后缀表达式
从左到右遍历中缀表达式中的每个数字和符号，若是数字则输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级不高于栈顶符号则栈顶元素依次出栈并输出，并将当前符号进栈，一直到最终输出后缀表达式为止。

（二）后缀表达式 -> 求值
从左到右遍历后缀表达式的每个数字和符号，遇到是数字就进栈，遇到是符号就将处于栈顶两个数字出栈，进行计算，运算结果进栈，一直到得到最终结果。

结构体的定义

一个存数字，一个存运算符

typedef struct 
{
    char *ch;
    int top;
}CharStack;

typedef struct
{
    int *num;
    int top;
}NumStack;

初始化

void InitCharStack(CharStack &S)
{
    S.ch = (char *)malloc(MAXSIZE * sizeof(char));
    
    if (S.ch == NULL) 
    {
    	printf("内存分配失败\r\n");
    	return;
	}
    S.top = -1;
    
    return;
}

void InitNumStack(NumStack &St)
{
	St.num = (int *)malloc(MAXSIZE * sizeof(int));

	St.top = -1;
	
	return;
}

进栈

//字符进栈
void PushCharStack(CharStack &S, char c)
{    
    if (S.top >= MAXSIZE-1) 
    {    
        printf("栈已满\r\n");
        return;
    }
    S.top ++;
    * ++S.ch = c;
    
    return;
}
//数字进栈
void PushNumStack(NumStack &St, int n)
{
	if (St.top == MAXSIZE) 
    {    
        printf("栈已满\r\n");
    }
    
	St.top ++;
	
	* ++St.num = n;
	
	return;
}

出栈

char PopCharStack(CharStack &S)
{   
    if (S.top == -1)
    {
        printf("栈为空\r\n");
        exit(1);
    }
    S.top --;
    char c = *S.ch --;
    
    return c;
}

int PopNumStack(NumStack &St)
{
	if (St.top == -1)
    {
        printf("栈为空\r\n");
    }
    St.top --;
    int num = *St.num --;
    
    return num;
}

获取字符栈栈顶元素

char GetStackTop(CharStack &S)
{
    char c = *S.ch;
    
    return c;
}

优先级判断

bool PriorJudge(char c1, char c2)
{
	if (c1 == '*' || c1 == '/') 
	   if (c2 == '+' || c2 == '-' || c2 == '(')
	      return true;
	if (c1 == '+' || c1 == '-')
	   if (c2 == '(') return true;
	   
	return false;
}

得到后缀表达式

char *InfixToSuffex(char *a, char *b)//infix中缀 suffex后缀 
{
    fgets(a, MAXSIZE-1, stdin);//从输入流中读取字符串
    
    printf("中缀表达式为:%s\r\n",a);
    
    int t = strlen(a);
    
    int k = 0;
    
    for (int i = 0; i < t; ++ i)
    {
    	
        if (a[i] >= '0' && a[i] <= '9')
        {
        	b[k ++] = a[i];
            if (a[i+1] < '0' || a[i+1] > '9')
                b[k ++] = '#';
        }
        
        else if (a[i] == ' ' || a[i] == '=') continue;
            
        else
        {
            if(S.top == -1 || a[i] == '(') 
			    PushCharStack(S, a[i]);
            
            else if (a[i] == ')')
            {
                while (S.top != -1 && GetStackTop(S) != '(')
				    b[k ++] = PopCharStack(S);
				    
				if (S.top != -1) PopCharStack(S);
                    
            }
            
            else
            {
                while (S.top != -1 && !PriorJudge(a[i], GetStackTop(S)))
                    b[k ++] = PopCharStack(S);
                    
                PushCharStack(S, a[i]);
            }
        }
        
    } 
    return b;
}

核心计算得到最终结果

int CaculatValue(char *b, NumStack &St)
{
	InitNumStack(St);
	int t = strlen(b);
	int num = 0;
	
	for (int i = 0; i < t; ++ i)
	{
		if (b[i] >= '0' && b[i] <= '9')
		{
		    num = 10 * num + b[i] - '0';
		    if (b[i+1] == '#') PushNumStack(St, num), num = 0;
	    }
		
		else
		{
			if (b[i] == '#') continue;
			
			int n = PopNumStack(St);
			int m = PopNumStack(St);
			
			if (b[i] == '+') PushNumStack(St, m + n);
			
			else if (b[i] == '-') PushNumStack(St, m - n);
			
			else if (b[i] == '*') PushNumStack(St, m * n);
			
			else PushNumStack(St, m / n);
		}
		
	}
	
	return PopNumStack(St);
}

完整代码实现

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

#define MAXSIZE 100

typedef struct 
{
    char *ch;
    int top;
}CharStack;

typedef struct
{
    int *num;
    int top;
}NumStack;

CharStack S;
NumStack St;

void InitCharStack(CharStack &S)
{
    S.ch = (char *)malloc(MAXSIZE * sizeof(char));
    
    if (S.ch == NULL) 
    {
    	printf("memory allocation failed\r\n");
    	return;
	}
    S.top = -1;
    
    return;
}

void PushCharStack(CharStack &S, char c)
{    
    if (S.top >= MAXSIZE-1) 
    {    
        printf("Stack is full!\r\n");
        return;
    }
    S.top ++;
    * ++S.ch = c;
    
    return;
}

char PopCharStack(CharStack &S)
{   
    if (S.top == -1)
    {
        printf("Stack is empty!\r\n");
        exit(1);
    }
    S.top --;
    char c = *S.ch --;
    
    return c;
}

char GetStackTop(CharStack &S)
{
    char c = *S.ch;
    
    return c;
}

bool PriorJudge(char c1, char c2)
{
	if (c1 == '*' || c1 == '/') 
	   if (c2 == '+' || c2 == '-' || c2 == '(')
	      return true;
	if (c1 == '+' || c1 == '-')
	   if (c2 == '(') return true;
	   
	return false;
}

char *InfixToSuffex(char *a, char *b)
{
    fgets(a, MAXSIZE-1, stdin);//从输入流中读取字符串
    
    printf("Infix expression is:%s\r\n",a);
    
    int t = strlen(a);
    
    int k = 0;
    
    for (int i = 0; i < t; ++ i)
    {
    	
        if (a[i] >= '0' && a[i] <= '9')
        {
        	b[k ++] = a[i];
            if (a[i+1] < '0' || a[i+1] > '9')
                b[k ++] = '#';
        }
        
        else if (a[i] == ' ' || a[i] == '=') continue;
            
        else
        {
            if(S.top == -1 || a[i] == '(') 
			    PushCharStack(S, a[i]);
            
            else if (a[i] == ')')
            {
                while (S.top != -1 && GetStackTop(S) != '(')
				    b[k ++] = PopCharStack(S);
				    
				if (S.top != -1) PopCharStack(S);
                    
            }
            
            else
            {
                while (S.top != -1 && !PriorJudge(a[i], GetStackTop(S)))
                    b[k ++] = PopCharStack(S);
                    
                PushCharStack(S, a[i]);
            }
        }
        
    } 
    return b;
}

void InitNumStack(NumStack &St)
{
	St.num = (int *)malloc(MAXSIZE * sizeof(int));

	St.top = -1;
	
	return;
}

void PushNumStack(NumStack &St, int n)
{
	if (St.top == MAXSIZE) 
    {    
        printf("Stack is full!\r\n");
    }
    
	St.top ++;
	
	* ++St.num = n;
	
	return;
}

int PopNumStack(NumStack &St)
{
	if (St.top == -1)
    {
        printf("Stack is empty!\r\n");
    }
    St.top --;
    int num = *St.num --;
    
    return num;
}

int CaculatValue(char *b, NumStack &St)
{
	InitNumStack(St);
	int t = strlen(b);
	int num = 0;
	
	for (int i = 0; i < t; ++ i)
	{
		if (b[i] >= '0' && b[i] <= '9')
		{
		    num = 10 * num + b[i] - '0';
		    if (b[i+1] == '#') PushNumStack(St, num), num = 0;
	    }
		
		else
		{
			if (b[i] == '#') continue;
			
			int n = PopNumStack(St);
			int m = PopNumStack(St);
			
			if (b[i] == '+') PushNumStack(St, m + n);
			
			else if (b[i] == '-') PushNumStack(St, m - n);
			
			else if (b[i] == '*') PushNumStack(St, m * n);
			
			else PushNumStack(St, m / n);
		}
		
	}
	
	return PopNumStack(St);
}

int main()
{
    InitCharStack(S);

    char a[MAXSIZE]={0};
    char b[MAXSIZE]={0};

    InfixToSuffex(a,b);

    printf("The suffix expression is:%s\r\n",b);
    int ans=CaculatValue(b,St);

    printf("The value of the expression is:%d\r\n",ans);
    return 0;
}

样例输出

9+(3-1)*3+10/2
Infix expression is:9+(3-1)*3+10/2

The suffix expression is:9#3#1#-3#*+10#2#/+
The value of the expression is:20

四、写在最后

希望我们都能学好数据结构。

AMBA-PV扩展与TLM接口：MTE和DMI实现详解
最新发布
weixin_30731305的博客
05-02 394
内存标记扩展(MTE)和直接内存接口(DMI)是现代SoC设计中实现安全关键功能的核心技术。MTE通过将4位标签与16字节内存块关联，为内存访问提供了细粒度的安全控制机制，其原理涉及标签颗粒计算、标签操作类型匹配等关键技术。DMI则通过直接内存访问机制显著提升系统级仿真效率，特别是在频繁访问相同内存区域时。这两种技术在汽车电子、物联网设备和医疗设备等安全敏感场景中具有重要应用价值。AMBA-PV扩展为TLM 2.0提供了完整的AMBA总线协议建模能力，特别是在AXI5和ACE总线上实现了MTE和DMI的高级
数据结构学习笔记——栈的基本知识和顺序存储结构实现栈（顺序栈）
小宇y的博客
05-04 9016
目录一、栈的相关知识二、顺序栈的定义三、顺序栈的初始化四、判断顺序栈是否为空栈五、判断顺序栈是否为满栈六、进栈（插入操作）七、出栈（删除操作）八、读取顺序栈顶元素九、顺序栈的建立一个简单的顺序栈的基本实现例子十、栈的遍历输出 一、栈的相关知识 栈是一种只允许在一端进行插入或删除操作的线性表，它是一种特殊的线性表，其遵循的原则是先进后出（FILO），即后进的元素先被取出来。由于它是一种线性表，所以有两种方式：顺序存储结构和链式存储结构表示，即顺序栈和链式栈。 其中，栈的插入操作称为进栈，栈的删除操作称为
【数据结构--栈的顺序存储结构】
qq_61719813的博客
05-11 2097
文章目录栈的顺序存储结构栈的定义栈的初始化压栈操作弹栈操作返回栈顶元素返回栈的长度将栈清空完整代码测试结果总结 栈的顺序存储结构 栈的定义 栈（stack）是限定仅在表尾进行插入和删除的线性表 允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为先进后出的线性表，简称LIFO结构。 栈的插入操作，叫做进栈，也称为压栈、入栈，如下图所示。 栈的删除操作，叫做出栈，也称为弹栈，如下图所示。 栈的结构定义： typedef struct CharSta
顺序栈——栈的顺序存储
weixin_73926427的博客
03-14 402
顺序栈：栈的顺序存储。
数据结构之栈的顺序存储结构及实现（C语言）
xiangjunyes的博客
05-30 4408
文章目录概念进栈出栈变化形式栈的顺序存储结构进栈操作出栈操作顺序栈代码 概念 栈（stack）是限定仅在表头和表尾进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last in First Out）的线性表，简称LIFO结构。 理解： 首先栈是一个线性结构，也就是说栈元素具有线性关系，即前驱后继关系。只不过栈是一种特殊的线性表而已。 它的特殊之处就在于限制了这个线性表的插入和删除的位置，它始终只在栈顶
数据结构与算法——栈的顺序结构及实现
xzt12138的博客
07-26 2592
像这样先进去反而要后出来的数据结构，我们称之为栈。
实验:基于顺序存储结构栈的实现与应用-数据结构（C语言）
kim的博客
04-04 1152
实验名称: 基于顺序存储结构栈的实现与应用 一、实验目的 加深对栈结构的概念、基本运算的理解； 熟练掌握栈的逻辑结构与物理结构的关系； 物理结构采用顺序存储结构,熟练掌握顺序栈结构各种基本运算的实现； 栈在解决实际问题中的应用。 二、实验环境安装设置 1. 启动DevCPP在E：建立工作区MyCpp，所有的程序源码都存放在该文件夹下。 三、实验任务 认真研读框架程序，根据提供的实验框架（框架可以直接运行），构造一个具有菜单的功能演示系统。根据功能要求实现顺序栈功能演示： ...
【数据结构】三、栈的顺序存储（顺序栈）、基本操作以及栈的应用--括号匹配算法 的实现
Yikou的个人技术博客
04-13 2070
顺序栈及顺序栈的基本操作c++实现；栈的应用--括号匹配算法实现。
【数据结构】栈的基本知识简介
zsc19990913的博客
02-18 3658
文章目录一、栈简介二、栈的插入2.1栈的顺序存储基本描述2.2栈的链式存储实现三、栈的应用 一、栈简介 栈（stack）是一种线性表结构，只允许在表的一端进行插入和删除操作的线性表。简单来说，栈一种后进先出（Last In First Out）的线性表，简称为LIFO结构。 把栈中允许插入和删除的一端成为栈顶（top）；另一段则成为栈底（bottom）。当表中没有任何元素是，称为空栈。从两个方面来解释栈的定义： 线性表：栈首先是一个线性表，按照次序依次进栈，栈顶元素为ana_nan​。 后进先出原则：每
【数据结构】线性表--栈
2401_85032912的博客
05-16 1096
数据结构、栈与队列、C语言
数据结构：栈
m0_72625526的博客
05-04 2246
栈(Stack)是只允许在一端进行插入或删除操作的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。栈顶(Top)线性表允许进行插入删除的那一端栈底(Bottom)固定的，不允许进行插入和删除的另一端。空栈不含任何元素。
【栈与队列】之栈的顺序存储（图文详细介绍！！）
qq_62822533的博客
12-21 6395
栈的顺序存储结构，以及栈顺序存储结构的一些实现，如：入栈，出栈，销毁栈，清空栈，求栈的长度等等。
顺序栈（栈的顺序储存结构）
q322359的博客
09-13 1315
顺序栈（栈的顺序储存结构）
数据结构-顺序栈详解（C语言）
m0_55698213的博客
10-20 4249
本文主要讲述顺序栈基本定义和特点以及顺序栈的C语言代码实现与顺序栈的实际应用。以上就是顺序栈的基本介绍，本文仅仅简单介绍了顺序栈概念、特点、运算以及顺序栈的应用。顺序栈是一种特殊的线性数据结构，它遵循先进后出（FILO）的原则，即在栈顶添加和删除元素。顺序栈在计算机科学中经常使用，因为它允许我们在高频率的情况下进行添加和删除操作。
栈的顺序存储结构及实现
dddgggd的博客
04-19 409
//栈的顺序储存结构 //顺序栈类的定义 typedef int ElemType; const int MAXSIZE = 100; class SqStack { private: ElemType elem[MAXSIZE]; int top; public: SqStack() { top = 0; } ~SqStack() { }; void SetEmpty() { top = 0; //置栈为空 } int IsEmpty(); //判断栈
详解顺序栈
D3540987120的博客
10-20 782
栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。/*seqstack.h顺序栈*//* 堆空间 */int top;/* 栈顶指针 */}SeqStack;/* 1. 初始化 *//* 2. 进（入）栈 *//* 3. 出栈 *//* 4. 取栈顶元素 *//* 5. 栈为空？*//* 6. 栈满？*/
栈和队列的操作一——栈的顺序存储结构
m0_72619231的博客
03-31 2477
两个 SElemType 类型的指针，栈顶指针top，栈底指针base,栈的长度stacksize;}SqStack;
栈的顺序存储结构（顺序栈）
一个搬运知识的笨小孩
07-27 5027
栈的顺序存储结构 1.顺序栈的存储结构 #define MAXSIZE 100 //顺序栈存储空间的初始分配 typedef struct{ SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int stacksize; //栈可用的最大容量 }SqStack; 2.顺序栈的初始化 初始化就是为顺序栈动态分配一个预定义大小的数组空间 栈属于逻辑结构 数组为顺序存储结构（存储/物理结构：逻辑结构在计算机中的存储形式） 具体关系见本人关于数据结构第一章图
栈的顺序存储结构
weixin_61898526的博客
04-19 1846
1.什么是栈? 栈是只限定仅在表尾进行插入和删除操作的线性表。 栈顶：插入和删除的一段(表尾) 栈底：表头 空栈：不含任何数据元素的栈 进栈、压栈、入栈：栈的插入操作 出栈、弹栈：栈的删除操作 栈的特点：后进先出 ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ALuoJi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值