数据结构：栈和队列的操作及应用

最新推荐文章于 2022-11-20 17:19:27 发布
原创 最新推荐文章于 2022-11-20 17:19:27 发布 · 326 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了栈和队列的基本操作，给出了C和C++实现的源代码链接。还列举了多个栈和队列的面试题，如括号匹配、用队列实现栈等，并给出分析。最后阐述了栈和队列的区别，包括进出顺序、操作位置和遍历速度等方面。
栈的基本操作

分为三部分，实现入栈，出栈，获取栈顶元素，获取栈内有效元素个数，置空，销毁等操作。
Stack.h

#pragma once
#include <assert.h>
#include <stdio.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* arr;
	int top;//标记栈顶，相当于顺序表中的size
	int capacity;
}Stack;
void StackInit(Stack* s);
void StackDestroy(Stack *s);
void StackPush(Stack *s,STDataType data);
void StackPop(Stack *s);
STDataType StackTop(Stack *s);
int StackEmpty(Stack *s);
int StackSize(Stack *s);

Stack.c

#include "Stack.h"
#include <malloc.h>
#include <string.h>
void StackInit(Stack* s)
{
	assert(s);
	s->arr = (STDataType*)malloc(sizeof(STDataType)* 3);
	if (NULL == s->arr)
	{
		assert(0);
		return;
	}
	s->capacity = 3;
	s->top = 0;
}
void CheckCapacity(Stack *s)
{
	assert(s);
	if (s->top == s->capacity)
	{
		int NewCapacity = s->capacity * 2;
		STDataType* temp = (STDataType*)malloc(sizeof(STDataType)*NewCapacity);
		if (NULL == temp)
		{
			assert(0);
			return;
		}
		memcpy(temp, s->arr, s->top*sizeof(STDataType));
		free(s->arr);
		s->arr = temp;
		s->capacity = NewCapacity;
	}
}
void StackPush(Stack *s, STDataType data)
{
	assert(s);
	CheckCapacity(s);//扩容
	s->arr[s->top] = data;
	s->top++;
}
void StackPop(Stack *s)
{
	assert(s);
	if (0 == s->top)//栈存在但是栈顶没有元素
		return;
	s->top--;
}
STDataType StackTop(Stack *s)//获取栈顶元素
{
	assert(s);
	return s->arr[s->top - 1];
}
int StackSize(Stack *s)//获取栈内有效元素个数
{
	assert(s);
	return s->top;
}
int StackEmpty(Stack *s)
{
	assert(s);
	return 0 == s->top;
}
void StackDestroy(Stack *s)
{
	assert(s);
	if (s->arr)
	{
		free(s->arr);
		s->arr = NULL;
		s->capacity = 0;
		s->top = 0;
	}
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"
#include <stdlib.h>
void menu()
{
	printf("***********************************************\n");
	printf("**  1.压栈           2.出栈                  **\n");
	printf("**  3.获取栈顶元素   4.获取栈内有效元素个数  **\n");
	printf("**  5.清空           6.销毁                  **\n");
}
void test()
{
	Stack s;
	int input = 0;
	STDataType data = 0;
	StackInit(&s);
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入要入栈的数:");
			scanf("%d", &data);
			StackPush(&s, data);
			break;
		case 2:
			StackPop(&s);
			break;
		case 3:
			data=StackTop(&s);
			printf("栈顶元素为:%d\n", data);
			break;
		case 4:
			data=StackSize(&s);
			printf("有效元素个数为:%d\n", data);
			break; 
		case 5:
			StackEmpty(&s);
			break;
		case 6:StackDestroy(&s);
			break;
		}
	} while (input);
}
int main()
{
	test();
	system("pause");
	return 0;
}

附加C++实现栈的操作源代码（学习C++与Linux后）（github）：
https://github.com/wangbiy/review/tree/master/stack

队列的基本操作

queue.h

#pragma once
typedef int QUDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QUDataType data;
}QueueNode;//结点
typedef struct Queue
{
	QueueNode* front;
	QueueNode* rear;
}Queue;
void QueueInit(Queue* pq);//初始化
void QueueDestroy(Queue* pq);//销毁
void QueuePush(Queue* pq, QUDataType data);//入队
void QueuePop(Queue* pq);//出队
QUDataType QueueFront(Queue* pq);//获取队头元素
QUDataType QueueBack(Queue* pq);//获取队尾元素
int Queuempty(Queue *pq);//置空
int QueueSize(Queue *pq);//获取有效元素个数
void QueueShow(Queue* pq);//显示

queue.c

#include "queue.h"
#include <assert.h>
#include <stdio.h>
#include <malloc.h>
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->front = pq->rear = NULL;

}
void QueueDestroy(Queue* pq)//销毁
{
	QueueNode* cur = NULL;
	assert(pq);
	cur = pq->front;
	while (cur)
	{
		pq->front = cur->next;
		free(cur);
		cur = pq->front;
	}
	pq->front = pq->rear = NULL;
}
QueueNode* BuyQueueNode(QUDataType data)
{
	QueueNode* pNewNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (pNewNode == NULL)
	{
		assert(0);
		return NULL;
	}
	pNewNode->data = data;
	pNewNode->next = NULL;
	return pNewNode;
}
void QueuePush(Queue* pq, QUDataType data)//入队,尾插
{
	assert(pq);
	QueueNode* pNewNode = NULL;
	pNewNode = BuyQueueNode(data);
	if (NULL == pq->rear)//空队列
	{
		pq->front = pq->rear=pNewNode;
	}
	else
	{
		pq->rear->next = pNewNode;
		pq->rear = pNewNode;
	}
}
void QueuePop(Queue* pq)//出队
{
	assert(pq);
	if (NULL == pq->front)
	{
		return;
	}
	else if (pq->front==pq->rear)//只有一个节点
	{
		free(pq->front);
		pq->front = pq->rear = NULL;
	}
	else//多个元素
	{
		QueueNode *Del = pq->front;
		pq->front = Del->next;
		free(Del);
	}
}
QUDataType QueueFront(Queue* pq)//获取队头元素
{
	assert(pq);
	return pq->front->data;
}
QUDataType QueueBack(Queue* pq)//获取队尾元素
{
	assert(pq);
	return pq->rear->data;
}
int Queuempty(Queue *pq)//置空
{
	assert(pq);
	return NULL == pq->front;
}
int QueueSize(Queue *pq)//获取有效元素个数
{
	QueueNode* cur = NULL;
	int count = 0;
	assert(pq);
	cur = pq->front;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}
void QueueShow(Queue* pq)
{
	QueueNode* cur = NULL;
	assert(pq);
	cur = pq->front;
	while (cur)
	{
		printf("%d---->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "queue.h"
#include <stdio.h>
#include <stdlib.h>
void menu()
{
	printf("***************************************\n");
	printf("**1.入队              2.出队         **\n");
	printf("**3.获取队头元素      4.获取队尾元素 **\n");
	printf("**5.获取有效元素个数  6.置空         **\n");
	printf("**7.销毁              8.显示         **\n");
	printf("***************************************\n");
}
void test()
{
	int input = 0;
	Queue q;
	QUDataType data = 0;
	QueueInit(&q);
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入要入队的元素:");
			scanf("%d", &data);
			QueuePush(&q, data);
			break;
		case 2:
			QueuePop(&q);
			break;
		case 3:
			data=QueueFront(&q);
			printf("队头元素为:%d\n", data);
			break;
		case 4:
			data = QueueBack(&q);
			printf("队尾元素为:%d\n", data);
			break;
		case 5:
			data=QueueSize(&q);
			printf("有效元素个数为:%d\n", data);
			break;
		case 6:
			Queuempty(&q);
			break;
		case 7:
			QueueDestroy(&q);
			break;
		case 8:
			QueueShow(&q);
			break;
		default:
			break;
		}
	} while (input);
}
int main()
{
	test();
	system("pause");
	return 0;
}

附加C++实现队列的基本操作源代码（学习Linux与C++后）（github）：
https://github.com/wangbiy/review/tree/master/Queue

栈和队列面试题

1.括号匹配问题(c++版,比较方便)

class Solution {
public:
    bool isValid(string s) {
        	std::stack<char> str;
        
		int size = s.size();//取字符串长度
		for (int i = 0; i < size; ++i)
		{
			char ch = s[i];
			switch (ch)
			{
			case '(':
			case '[':
			case '{':
				str.push(ch);
				break;
			case ')':
			case ']':
			case '}':
			{
						if (str.empty())
						{
							return false;
						}
						char left = str.top();
                        str.pop();
						if (!((left == '('&&ch == ')')
							|| (left == '['&&ch == ']') || (left == '{'&&ch == '}')))
						{
							return false;
						}
						break;
			}

			}

		}
		if (!str.empty())
		{
			return false;
		}
		return true;
    }
};

分析：输入字符串，遍历取出字符串的每个字符，当遇到左括号时，入栈，当遇到右括号时，判断栈内是否为空，若为空，返回false，否则取出栈顶元素，出栈，与右括号比较判断是否匹配，如果不匹配，返回false，循环结束，若栈内还有元素，返回false，否则返回true。
2.用队列实现栈

class MyStack {
    std::queue<int> q;
public:
    MyStack() {      
    }
    void push(int x) {
        q.push(x);
        
    }
    int pop() {
        int n=q.size();
        for(int i=0;i<n-1;i++)
        {
            int v=q.front();
            q.pop();
            q.push(v);
        }
        int v=q.front();
        q.pop();
        return v;
    }
    int top() {
        int n=q.size();
        for(int i=0;i<n-1;i++)
        {
            int v=q.front();
            q.pop();
            q.push(v);
        }
        int v=q.front();
        q.pop();
        q.push(v);
        return v;        
    }
    bool empty() {
        return q.empty();        
    }
};

分析：进行压栈操作实际上就是数据入队列，直接将x进入队列，出栈要满足后进先出原则，而队列满足先进先出原则，因此，应当让前n-1个元素先从头部出队列，再从尾部入队列，返回队头元素，查看栈顶元素一样的道理，唯一不同的是只是看一眼队头元素，之后将它进入队列，判断栈内是否为空就是判断队列是否为空。
3.用栈实现队列

class MyQueue {
    std::stack<int> in;
    std:: stack<int> out;
public:
    MyQueue() {
        
    }
    void push(int x) {
        in.push(x);
        
    }
    int pop() {
        if(out.empty())
        {
            int n=in.size();
            for(int i=0;i<n;i++)
            {
                int v=in.top();
                in.pop();
                out.push(v);
            }
        }
        int v=out.top();
        out.pop();
        return v;       
    }
    int peek() {
         if(out.empty())
        {
            int n=in.size();
            for(int i=0;i<n;i++)
            {
                int v=in.top();
                in.pop();
                out.push(v);
            }
        }
        int v=out.top();
        return v;       
    }
    bool empty() {
        
        return in.empty()&&out.empty();    
    }
};

分析：定义两个栈，一个保存进来的元素，一个保存出去的元素，要用栈实现队列，进队列实际上就是进栈，出队列时，如果out栈为空，将in栈的栈顶元素一一取出，进入out栈，之后一一去out栈的元素，出栈。取队列首部的元素与之道理一样，不过不用出栈，只用看一眼就行，判断队列是否为空，只要两个栈都为空，队列为空。
4.实现一个最小栈

class MinStack {
    std:: stack<int> nomal;
    std:: stack<int> min;
public:
    MinStack() {
        
    }    
    void push(int x) {
        nomal.push(x);
        if(min.empty()||x<=min.top())
        {
            min.push(x);
        }
        else
        {
            min.push(min.top());
        }    
    }    
    void pop() {
        nomal.pop();
        min.pop();       
    }  
    int top() {
        return nomal.top();
    }  
    int getMin() {
        return min.top();
    }
};

分析：定义两个栈，一个存放每个元素，一个存放小的元素，先将一个元素进入nomal栈，如果min栈是空的或者接下来的元素小于min栈的栈顶元素，进入min栈，否则将min栈的栈顶元素进入min栈，这样min栈的栈顶元素一定为最小元素，在进行出栈操作时，nomal栈出一个，min栈出一个，取栈顶元素即是取nomal栈元素，取最小元素即是取min栈栈顶元素。
5.循环队列

class MyCircularQueue {
   int *arr;
   int size;
   int front;
   int rear;
   int capacity;
public:
   MyCircularQueue(int k) {
       arr=(int*)malloc(sizeof(int)*k);
       capacity=k;
       size=0;
       front=0;
       rear=0;        
   }
   bool enQueue(int value) {
       if(size>=capacity)
       {
           return false;
       }
       arr[rear]=value;
       rear=(rear+1)%capacity;
       size++;  
       return true;
   }
   bool deQueue() {
       if(size==0)
           return false;
       size--;
       front=(front+1)%capacity;
       return true;
       
   }
   int Front() {
       if(size==0)
           return -1;
       return arr[front];   
   }
   int Rear() {
       if(size==0)
           return -1;
       int index=(rear+capacity-1)%capacity;
       return arr[index];
       
   }
   bool isEmpty() {
       return size==0;
       
   }
   
   bool isFull() {
       return size==capacity;
       
   }
};

分析：实现循环队列，开辟一个动态空间，实现入队操作，如果有效元素个数大于容量，返回false，将value放入队列，如果到达队尾，实现循环，通过（rear+1）%capacity,使得rear==front,重新开始，出队列具有相同的道理，出队，front向后走，一直到队尾，进行取模操作，到达队头，在取队尾元素时，如果队列为空，返回false，(rear+capacity-1)%capacity可得到队尾位置。
6、逆波兰表达式
分析：逆波兰表达式，即后缀表达式，例如：2+1*3的逆波兰表达式就是2 1 3 * +，那么如何给定一个逆波兰表达式来求值，首先：取出元素，如果该元素是数字，入栈，否则，先到栈顶取当前运算符的右操作数，出栈，然后又在栈顶取左操作数，出栈，进行当前运算，将结果压栈，继续进行，直到所有元素处理完，这时栈顶元素就是运算结果。注意区分是负号还是减号，如果是负号，说明这个元素后面还有元素，否则后面为’\0’。
代码见下：

int evalRPN(char ** tokens, int tokensSize){
    Stack s;
    int ret=0;
    StackInit(&s);
    for(int i=0;i<tokensSize;++i)
    {
        char* str=tokens[i];
        if(!('+'==str[0] || ('-'==str[0]&&str[1]=='\0')||'*'==str[0]||'/'==str[0]))//说明不是运算符
        {
            StackPush(&s,atoi(str));
        }
        else//说明是运算符
        {
            int right=StackTop(&s);
            StackPop(&s);
            int left=StackTop(&s);
            StackPop(&s);
            switch(str[0])
            {
                case '+':
                    StackPush(&s,left+right);
                    break;
                case '-':
                    StackPush(&s,left-right);
                    break;
                case '*':
                    StackPush(&s,left*right);
                    break;
                case '/':
                    StackPush(&s,left/right);
                    break;
            }
        }       
    }
    ret=StackTop(&s);
    StackDestroy(&s);
    return ret;
}

7.验证栈序列
验证栈序列就是给一个入栈序列和出栈序列，判断这个出栈序列是否能由入栈序列得到，如果可以，返回true，否则返回false
分析：定义两个指针，一个指向入栈序列头，一个指向出栈序列头，如果此时栈是空的或者此时栈顶元素与出栈指针指向的元素不相等，继续让入栈序列的元素入栈，入栈指针向后走，直到遇到与出栈指针指向的元素相等的栈顶元素时，取出栈顶元素，出栈指针向后走，循环，直到出栈指针越界，说明出栈序列遍历完成，结束。
代码见下：

bool validateStackSequences(int* pushed, int pushedSize, int* popped, int poppedSize){
    Stack s;
    int inidx=0;
    int outidx=0;
    StackInit(&s);
    while(outidx<poppedSize)
    {
        while(StackEmpty(&s)||StackTop(&s)!=popped[outidx])//栈为空或者栈顶元素不等于popped栈的元素，入栈
        {
            if(inidx<pushedSize)
            {
                StackPush(&s,pushed[inidx++]);
            }
            else
             return false;
        }
        //栈顶元素等于popped栈的元素，出栈，outidx++
     StackPop(&s);
     outidx++;
    }
    return true;
}

8.用栈将递归转换为循环
例如，我们在实现单链表的逆置时，一般采用递归的方法，例如：

void printList(Node* pHead)
{
	if(pHead)
	{
		printList(pHead->next);
		printf("%d ",phead->data);
	}
}

但是这种方法很有可能会造成栈溢出，可以发现，递归的过程类似于栈的特性先进后出，因此可以使用栈将递归转换为循环，这样就不会产生栈溢出的问题，将上述代码可以变为：

void printList(Node* pHead)
{
	Node* cur=pHead;
	Stack s;
	StackInit(&s);
	while(cur)
	{
		StackPush(&s,cur->data);
		cur=cur->next;
	}
	while(!StackEmpty(&s))
	{
		printf("%d ",StackTop(&s));
		StackPop(&s);
	}
	StackDestroy(&s);
}
栈和队列的区别：

1.栈是先进后出，队列是先进先出
2.栈只允许在一头进行插入和删除，队列在一端插入，另一端删除
3.在栈中遍历数据需要扫描全部元素，而队列可以从两端扫描，所以相对来说队列比较快

栈和队列的基本操作和应用
LiXingyue
08-23 750
本文主要内容： 栈的基本操作及实现 队列的基本操作及实现 栈和队列的应用 1.栈：先进后出、后进先出 （1）栈顶是当前水平面的位置top （2）栈的基本操作： push：压栈，放入数据 pop：弹栈，删除此堆数据 peek：查看堆顶元素 empty：判断栈是否为空 search：查找元素 （3）实现：链表可以实现栈（头插头删），顺序表也可以实现栈（尾插、尾删）,时间复杂度均为o(1) （4）S...
栈和队列的基本操作及应用
分不清东西南北的Laffey
11-06 1040
问题描述 商店货架以栈的方式摆放商品。生产日期越近的越靠近栈底，出货时从栈顶取货。一天营业结束，如果货架不满，则需上货。入货直接将商品摆放到货架上，则会使生产日期越近的商品越靠近栈顶。这样就需要倒货架，使生产日期越近的越靠近栈底。 基本要求 设计一个算法，保证每一次上货后始终保持生产日期越近的商品越靠近栈底。 #include&lt;iostream&gt; #define MAXSIZE 100...
栈和队列的基本操作及其应用
04-15
1、掌握栈和队列的顺序存储结构和链式存储结构，以便在实际中灵活应用。 2、掌握栈和队列的特点，即后进先出和先进先出的原则。 3、掌握栈和队列的基本运算，如：入栈与出栈，入队与出队等运算在顺序存储结构和链式存储结构上的实现。
【数据结构】栈与队列的基本操作及其应用
weixin_72437555的博客
11-20 1783
栈和队列是两种重要的线性结构，从数据结构的角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表的子集。他们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，他们是和线性表大不相同的两类重要的的抽象数据类型。​笔者本周粗略学习了栈与队列的知识及其应用，特此总结记录自己的经验。(学完之后cpu烧了/(ㄒoㄒ)/~~)提示：以下是本篇文章正文内容，下面案例可供参考栈(Stack):一种可以实现“先进后出”的存储结构。可以将其想象为箱子，先放进箱子的东西后拿出来。
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构实验指南：栈与队列算法设计与应用
10-14
本文档是一份详细的数据结构实验教学材料，涵盖栈（两种形式分别为顺序栈和链栈）与队列（包括环形队列和链队）的基础操作算法的学习实践，重点在于理解和运用这些基本概念。主要内容围绕着对各种数据结构实现具体的...
《C语言数据结构实战：栈与队列的奇妙冒险》
最新发布
10-08
内容概要：本文通过C语言实战讲解栈与队列两大基础数据结构的核心概念、实现方式及其典型应用场景。文章首先介绍栈（LIFO）和队列（FIFO）的基本特性与操作，并分别演示了数组和链表两种实现方法。随后深入探讨栈在...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
C语言实现数据结构：栈和队列操作详解
资源摘要信息: 本文档详细介绍了数据结构中栈和队列的概念、操作及C语言实现。栈是一种后进先出（LIFO）的数据结构，支持两种主要操作：push（入栈）和pop（出栈），以及辅助操作如获取栈顶元素和打印栈内容。队列是...
栈和队列的基本操作实现及其应用
04-28
一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 2、会用栈和队列解决简单的实际问题。 二、实验内容 （可任选或全做） 假设称正读数和反读数都相同的字符序列为“回文”，例如，‘abba’和‘abcba’是回文，‘abcde’和‘ababab’则不是回文。试写一个算法判断别读入的一个以‘@’为结束符的字符序列是否是“回文”。 [实现提示] 　　首先，序列1进栈，然后序列1出栈并与序列2比较 相关常量及结构定义： # define STACK_INIT_SIZE 100 # define STACKINCREMENT 10 # define OK 1 # define ERROR 0 typedef int SElemType; //栈类型定义 typedef struct SqStack { SElemType *base; SElemType *top; int stacksize; }SqStack; 设计相关函数声明： 判断函数：int IsReverse() 栈：int InitStack(SqStack &S ) int Push(SqStack &S, SElemType e ) int Pop(SqStack &S,SElemType &e) int StackEmpty(s) 2、编程模拟队列的管理，主要包括：出队列、入队、统计队列的长度、查找队列某个元素e、及输出队列中元素。
栈和队列基本操作及练习
08-05
栈和队列基本操作及练习
栈和队列的基本操作
Const帆的博客
07-24 1844
栈：头添加头删除 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct node1 { int nValue; struct node1 *pNext; }MyStack; typedef struct node2 { int nCount; MyStack *pTop; }Stack; void s_Init...
栈与队列基本操作及其应用
qq_46672746的博客
06-21 1578
文章目录一、栈栈的实现顺序栈栈的应用1.数制转换(十进制转换为R进制)2.括号匹配的检验二、队列队列的实现1.队列的链式表示和实现2.循环队列-队列的顺序表示和实现队列的应用1.用循环队列模拟银行窗口排队 一、栈 栈的实现 顺序栈 #include <iostream> using namespace std; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 //不可执行 #de
栈和队列基本操作与应用
qq_59126785的博客
12-10 410
数据结构——栈和队列
【数据结构】栈和队列的应用
慢热型网友的博客
06-12 569
1.实现顺序栈各种基本运算的算法，具体操作要求如下： （1）初始化栈，并判断栈是否为空； （2）对a,b,c,d,f五个字符元素模拟进栈操作；并判断栈是否为空； （3）取出栈顶元素；（4）对a,b,c,d,f五个字符元素做依次出栈操作，并判断栈是否为空；（5）释放栈。 ...
数据结构--栈和队列的应用
知足且上进，温柔而坚定
08-31 1337
一 、 栈的应用 1 . 栈在括号匹配中的应用 1-1 顺序栈实现 #include <iostream> using namespace std; #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize];//最大容量 int top;//栈顶指针 } SqStack; //初始化栈 void InitStack(SqStack &S); //判断栈空
数据结构栈和队列的使用
智的博客
03-31 1008
数据结构线性结构的应用------栈线性结构的应用------队列 这是我最近学习的笔记，还会持续更新，如果兄弟们看见那里需要修改的地方请告诉我 前述：栈和队列是一种特殊的线性结构，是连续存储或离散存储的一种应用 线性结构的应用------栈 定义：一种可以实现的先进后出存储结构，类似于箱子 分类：1 .静态栈 2. 动态栈 算法：1.出栈 2. 压栈 应用：1.函数调用 2. 中断 3....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值