数据结构——栈

最新推荐文章于 2022-11-15 21:41:10 发布
最新推荐文章于 2022-11-15 21:41:10 发布
阅读量124 收藏
点赞数
文章标签： 数据结构 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43211535/article/details/100065934
版权

一.什么是栈

栈是一种机制：后进先出 LIFO：last in first out

二.单一数据类型栈

main函数文件：
#include <iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;


/**********************************************************************************/
/*
	栈类
	要求
		MyStack(int size);            //分配初始内存初始化栈空间，设定栈容量，栈顶
		~MyStack（）；                //回收栈空间内存
		bool stackEmpty（）;          //判断栈是否为空
		bool stackFull();             //判断栈是否为满
		void clearStack();            // 清空栈
		int stackLength();            //已有元素个数
		void push(char elem);         //元素入栈，栈顶上升
		char pop(char &elem);         //元素出栈，栈顶下降
		void stackTraverse();         //比那里栈汇中所有元素

		目的：掌握栈的实现原理和运行机制
*/
/***********************************************************************************/

int main(void)
{
	MyStack *pStack = new MyStack(5);
	pStack->push('h');      //底
	pStack->push('e');
	pStack->push('l');
	pStack->push('l');
	pStack->push('o');     //顶

	pStack->stackTraverse(true);
	char elem = 0;
	pStack->pop(elem);
	cout << endl;
	cout << elem << endl;

	//pStack->clearStack();
	pStack->stackTraverse(false);

	cout << pStack->stackLength() << endl;

	if (pStack->stackEmpty())
	{
		cout << "栈为空" << endl;
	}

	if (pStack->stackFull())
	{
		cout << "栈为满" << endl;
	}


	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;
}



MyStack.h和MyStack.cpp文件：

class MyStack
{
public:
	MyStack(int size);       //分配内存初始化栈空间，设定栈容量，栈顶
	~MyStack();              //回收站空间
	bool stackEmpty();          
	bool stackFull();        
	void clearStack();
	int stackLength();
	bool push(char elem);
	bool pop(char &elem);      
	void stackTraverse(bool isFromButtom);         //遍历栈中所有元素

private:
	char *m_pBuffer;     //栈空间指针
	int m_iSize;        //栈容量
	int m_iTop;       //栈顶，栈中元素个数
};





#include "MyStack.h"
#include<iostream>
using namespace std;


MyStack::MyStack(int size)
{
	m_iSize = size;
	m_pBuffer = new char[size];
	m_iTop = 0;
}

MyStack::~MyStack()
{
	delete[]m_pBuffer;
}

bool MyStack::stackEmpty()
{
	if (0 == m_iTop)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool MyStack::stackFull()
{
	if (m_iTop==m_iSize)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void MyStack::clearStack()
{
	m_iTop = 0;
}

int MyStack::stackLength()
{
	return m_iTop;
}

bool MyStack::push(char elem)
{
	if (stackFull())
	{
		return false;
	}
	else
	{
		m_pBuffer[m_iTop] = elem;
		m_iTop++;
		return true;
	}
}


/*char MyStack::pop()
{
	if (stackEmpty())
	{
		throw 1;
	}
	else
	{
		m_iTop--;
		return m_pBuffer[m_iTop];
	}
}*/

bool MyStack::pop(char &elem)
{
	if (stackEmpty())
	{
		return false;
	}
	else
	{
		m_iTop--;
		elem = m_pBuffer[m_iTop];
		return true;
	}
}

void MyStack::stackTraverse(bool isFromButtom)
{
	if (isFromButtom)
	{
		for (int i = 0; i < m_iTop; i++)
		{
			cout << m_pBuffer[i] << ",";
		}
	}
	else
	{
		for (int i = m_iTop - 1; i >= 0; i--)
		{
			cout << m_pBuffer[i] << ",";
		}
	}
	
}

三.存放复杂数据类型

栈中存放的是对象的时候要做一些修改，具体实现如下代码

main函数文件：

#include <iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;

/**********************************************************************************/
/*
	栈类
	要求
		MyStack(int size);            //分配初始内存初始化栈空间，设定栈容量，栈顶
		~MyStack（）；                //回收栈空间内存
		bool stackEmpty（）;          //判断栈是否为空
		bool stackFull();             //判断栈是否为满
		void clearStack();            // 清空栈
		int stackLength();            //已有元素个数
		void push(char elem);         //元素入栈，栈顶上升
		char pop(char &elem);         //元素出栈，栈顶下降
		void stackTraverse();         //比那里栈汇中所有元素

		目的：掌握栈的实现原理和运行机制
*/
/***********************************************************************************/

int main(void)
{
	MyStack *pStack = new MyStack(5);
	pStack->push(Coordinate(1,2));      //底
	pStack->push(Coordinate(3,4));     //顶

	pStack->stackTraverse(true);
	
	pStack->stackTraverse(false);

	cout << pStack->stackLength() << endl;

	if (pStack->stackEmpty())
	{
		cout << "栈为空" << endl;
	}

	if (pStack->stackFull())
	{
		cout << "栈为满" << endl;
	}

	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;
}





Coordinate.h和Coordinate.cpp文件：


#ifndef COORDINATE_H
#define COORDINATE_H

class Coordinate
{
public:
	Coordinate(int x=0, int y=0);
	void printCoordinate();


private:
	int m_iX;
	int m_iY;

};



#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate(int x, int y)
{
	m_iX = x;
	m_iY = y;
}

void Coordinate::printCoordinate()
{
	cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

 
MyStack.h和MyStack.cpp文件：

#include"Coordinate.h"

class MyStack
{
public:
	MyStack(int size);       //分配内存初始化栈空间，设定栈容量，栈顶
	~MyStack();              //回收站空间
	bool stackEmpty();          
	bool stackFull();        
	void clearStack();
	int stackLength();
	bool push(Coordinate elem);
	bool pop(Coordinate &elem);
	void stackTraverse(bool isFromButtom);         //遍历栈中所有元素

private:
	Coordinate *m_pBuffer;     //栈空间指针
	int m_iSize;        //栈容量
	int m_iTop;       //栈顶，栈中元素个数
};



#include "MyStack.h"
#include<iostream>
using namespace std;


MyStack::MyStack(int size)
{
	m_iSize = size;
	m_pBuffer = new Coordinate[size];
	m_iTop = 0;
}

MyStack::~MyStack()
{
	delete[]m_pBuffer;
}

bool MyStack::stackEmpty()
{
	if (0 == m_iTop)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool MyStack::stackFull()
{
	if (m_iTop==m_iSize)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void MyStack::clearStack()
{
	m_iTop = 0;
}

int MyStack::stackLength()
{
	return m_iTop;
}

bool MyStack::push(Coordinate elem)
{
	if (stackFull())
	{
		return false;
	}
	else
	{
		m_pBuffer[m_iTop] = elem;
		m_iTop++;
		return true;
	}
}


/*char MyStack::pop()
{
	if (stackEmpty())
	{
		throw 1;
	}
	else
	{
		m_iTop--;
		return m_pBuffer[m_iTop];
	}
}*/

bool MyStack::pop(Coordinate &elem)
{
	if (stackEmpty())
	{
		return false;
	}
	else
	{
		m_iTop--;
		elem = m_pBuffer[m_iTop];
		return true;
	}
}

void MyStack::stackTraverse(bool isFromButtom)
{
	if (isFromButtom)
	{
		for (int i = 0; i < m_iTop; i++)
		{
			//cout << m_pBuffer[i] << ",";
			m_pBuffer[i].printCoordinate();
		}
	}
	else
	{
		for (int i = m_iTop - 1; i >= 0; i--)
		{
		//	cout << m_pBuffer[i] << ",";
			m_pBuffer[i].printCoordinate();
		}
	}
	
}

 

四.栈模板

main函数文件：

#include <iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;
#include"Coordinate.h"

/**********************************************************************************/
/*
	栈类
	要求
		MyStack(int size);            //分配初始内存初始化栈空间，设定栈容量，栈顶
		~MyStack（）；                //回收栈空间内存
		bool stackEmpty（）;          //判断栈是否为空
		bool stackFull();             //判断栈是否为满
		void clearStack();            // 清空栈
		int stackLength();            //已有元素个数
		void push(char elem);         //元素入栈，栈顶上升
		char pop(char &elem);         //元素出栈，栈顶下降
		void stackTraverse();         //比那里栈汇中所有元素

		目的：掌握栈的实现原理和运行机制
*/
/***********************************************************************************/

int main(void)
{
	MyStack<char> *pStack = new MyStack<char>(5);
	pStack->push('h');      //底
	pStack->push('l');     //顶

	pStack->stackTraverse(true);
	
	pStack->stackTraverse(false);

	cout << pStack->stackLength() << endl;

	if (pStack->stackEmpty())
	{
		cout << "栈为空" << endl;
	}

	if (pStack->stackFull())
	{
		cout << "栈为满" << endl;
	}

	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;
}





Coordinate.h文件：

#ifndef COORDINATE_H
#define COORDINATE_H
#include<ostream>
#include<iostream>
using namespace std;

class Coordinate
{
	friend ostream &operator<<(ostream &out, Coordinate &coor);
public:
	Coordinate(int x = 0, int y = 0)
	{		
		m_iX = x;
    	m_iY = y;		
	}
	void printCoordinate()
	{
		cout << "(" << m_iX << "," << m_iY << ")" << endl;
	}

private:
	int m_iX;
	int m_iY;

};

ostream &operator<<(ostream &out, Coordinate &coor)
{
	out << "(" << coor.m_iX << "," << coor.m_iY << ")" << endl;

	return out;
}





MyStack.h文件：

template <typename   T>
class MyStack
{
public:
	 MyStack(int size);       //分配内存初始化栈空间，设定栈容量，栈顶
	~MyStack();              //回收站空间
	bool stackEmpty();          
	bool stackFull();        
	void clearStack();
	int stackLength();
	bool push(T elem);
	bool pop(T &elem);
	void stackTraverse(bool isFromButtom);         //遍历栈中所有元素

private:
	T *m_pBuffer;     //栈空间指针
	int m_iSize;        //栈容量
	int m_iTop;       //栈顶，栈中元素个数
};


template <typename   T>
MyStack<T>::MyStack(int size)
{
	m_iSize = size;
	m_pBuffer = new T[size];
	m_iTop = 0;
}

template <typename   T>
MyStack<T>::~MyStack()
{
	delete[]m_pBuffer;
}

template <typename   T>
bool MyStack<T>::stackEmpty()
{
	if (0 == m_iTop)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template <typename   T>
bool MyStack<T>::stackFull()
{
	if (m_iTop == m_iSize)
	{
		return true;
	}
	else
	{
		return false;
	}
}

template <typename   T>
void MyStack<T>::clearStack()
{
	m_iTop = 0;
}

template <typename   T>
int MyStack<T>::stackLength()
{
	return m_iTop;
}

template <typename   T>
bool MyStack<T>::push(T elem)
{
	if (stackFull())
	{
		return false;
	}
	else
	{
		m_pBuffer[m_iTop] = elem;
		m_iTop++;
		return true;
	}
}


/*
template <typename   T>
char MyStack::pop()
{
if (stackEmpty())
{
throw 1;
}
else
{
m_iTop--;
return m_pBuffer[m_iTop];
}
}*/

template <typename   T>
bool MyStack<T>::pop(T &elem)
{
	if (stackEmpty())
	{
		return false;
	}
	else
	{
		m_iTop--;
		elem = m_pBuffer[m_iTop];
		return true;
	}
}

template <typename   T>
void MyStack<T>::stackTraverse(bool isFromButtom)
{
	if (isFromButtom)
	{
		for (int i = 0; i < m_iTop; i++)
		{
			cout << m_pBuffer[i];
			//m_pBuffer[i].printCoordinate();
		}
	}
	else
	{
		for (int i = m_iTop - 1; i >= 0; i--)
		{
			cout << m_pBuffer[i];
			//	m_pBuffer[i].printCoordinate();
		}
	}

}

五.应用——进制转换

mian函数文件：（MyStack.h为栈模板，前面例子有）

#include <iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;


/**********************************************************************************/
/*
	栈应用——数据转换
	描述：输入任意的十进制正整数N，分别输出改正数N的二进制、八进制、十六进制的数
	公式：N=（N div d）*d+N mod d(div表示整除，mod表示求余)

	（1348）（十进制）=（2504）（八进制）=（544）（十六进制）=（10101000100）（二进制）

*/
/***********************************************************************************/

#define BINARY       2
#define OCTONARY     8
#define HEXADECIMAL 16

int main(void)
{
	char num[] = "0123456789ABCDEF";
	MyStack<int> *pStack = new MyStack<int>(20);
	
	int N = 2019;
	int mod = 0;
	while (N != 0)
	{
		mod = N % HEXADECIMAL;
		pStack->push(mod);
		N = N / HEXADECIMAL;
		
	}
	//pStack->stackTraverse(false);
	//for (int i = p->pStack->stackTraverse(false)-1;i>=0;i--)
	//{
	//	num[pStack[i]];//但是我们的栈现在并没有下标功能除非改造一下
	//}
	int elem = 0;
	while(!pStack->stackEmpty())
	{
		pStack->pop(elem);
		cout << num[elem] ;
	}
	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;
}

六.应用——括号匹配

#include <iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;
#include"Coordinate.h"

/**********************************************************************************/
/*
	栈应用——括号匹配
	描述：任意输入一组括号，可以判断括号是否匹配
	字符串示例：[()]  [()()] [()[()]] [[()]
*/
/***********************************************************************************/

#define BINARY       2
#define OCTONARY     8
#define HEXADECIMAL 16

int main(void)
{
	MyStack<char>*pStack = new MyStack<char>(30);
	MyStack<char>*pNeedStack = new MyStack<char>(30);

	char str[] = "[[((]))]";
	char currentNeed = 0;
	for (int i = 0; i < strlen(str); i++)
	{
		if (str[i] != currentNeed)
		{
			pStack->push(str[i]);
			switch (str[i])
			{
			case '[':
				if (currentNeed != 0)
				{
					pNeedStack->push(currentNeed);
				}
				currentNeed = ']';
				break;
			case '(':
				if (currentNeed != 0)
				{
					pNeedStack->push(currentNeed);
				}
				currentNeed = ')';
				break;
			default:
				cout << "字符串不匹配" << endl;
				system("pause");
				return 0;
			}
		}
		else
		{
			char elem;
			pStack->pop(elem);
			if(!pNeedStack->pop(currentNeed))
			{
				currentNeed = 0;
			}
		}
	}

	if (pStack->stackEmpty())
	{
		cout << "字符串匹配" << endl;
	}
	else
	{
		cout << "字符串不匹配" << endl;
	}



	delete pStack;
	pStack = NULL;

	delete pNeedStack;
	pStack = NULL;
	system("pause");
	return 0;
}

 

菜菜的狗子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++数据结构——栈.pdf
07-11
C++数据结构——栈 C++数据结构 数据结构——栈 栈 最近计划再复习⼀遍数据结构，看到⼀篇博客：。 1、栈(Stack)是⼀种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守"先进后出"(First In Last Out)的原则...
栈和队列
Maystyle的博客
05-08 779
他们均是线性表的应用和推广。 1.栈 ==定义：==只允许在一端进行插入或删除操作的线性表。栈顶是允许进行插入删除的那一端。栈底是固定的。具有后进先出的特点。 （研究数据结构的注意点：逻辑结构、存储结构和对数据的运算） 栈的数学性质： n个元素进栈，出栈排列顺序为C2n n/(n+1)。 栈的顺序结构： 维护一个数组和栈顶指针。 进栈：指针+1，进栈。 出栈：出栈，指针-1 栈空：top=-1 不同的栈顶指针设置方式，操作会有所不同。 顺序栈之共享栈： 利用栈底位置相对不变的特性，可以让两个顺序栈共享一个.
栈与队列
wr8023nt的博客
02-07 211
栈是限定在表尾进行插入和删除的操作的线性表； 队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表； 队列满的条件是  (rear  + 1)%queuesize == front; 队列长度公式为 (rear - front + queuesize)%queuesize rear为队尾front为队头； 初始化一个空队列 {  q->front
数据结构实验——顺序栈
D1379951481的博客
11-15 1017
顺序栈操作：1.初始化栈，2.销毁栈，3.清空栈，4.栈判空，5.求栈长度，6.获取栈顶元素，7.插入一个 元素，8.删除一个元素，9输出所有元素，10进制转换。
栈的知识点总结（顺序栈和链栈）——应用：数制转换
一丁的博客
04-18 4249
目录 一、栈的逻辑结构 1.栈定义 2.栈与线性表的区别与联系 3.栈的相关运算 4.要对栈状态进行标示，仅需要一个参数即可。 二、顺序栈 1.顺序栈数据结构 2.顺序栈初始化 3.判断栈空和栈满 4.压栈 5.弹栈 6.取栈顶元素 7.顺序栈进行数制转换，实现10进制转8进制 三、链栈 1.链栈数据结构定义 2.初始化 3.判断栈空 4.压栈 5.弹栈 6...
【数据结构】栈
梓莘
03-07 552
递归 一、概念 递归就是方法自己调用自己,每次调用时传入不同的变量**.递归有****助于编程者解决复杂的问题**,同时可以让代码变得简洁。 二、 递归能解决什么问题 各种数学问题如: 8皇后问题 , 汉诺塔, 阶乘问题, 迷宫问题, 球和篮子的问题(google编程大赛) 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等. 将用栈解决的问题–>递归代码比较简洁...
数据结构——栈 括号匹配 C语言
03-16
假设一个字符串包含三种括号：圆括号‘(’ 和 ‘)’，方括号‘[’ 和 ‘]’，花括号 ‘{’和‘}’，且这三种括号可按任意的次序排列，请判断括号是否完全匹配。如果不能匹配，输出"No"；如果能匹配，则输出"Yes"。
算法和数据结构——栈.pdf
08-07
#资源达人分享计划#
一本通数据结构——栈的习题，很全，希望您能喜欢
08-10
一本通数据结构——栈的习题，很全，希望您能喜欢
n个元素进栈,共有多少种出栈顺序(公式)
weixin_30298497的博客
04-09 4966
C(2n,n)/(n+1) 转载于:https://www.cnblogs.com/mcyushao/p/10677902.html
栈（一）利用栈计算表达式
hua_juan的博客
09-30 1724
整理了一下使用数据结构这本书上的内容顺序栈类 sq_Stack.h#pragma once #include using namespace std; template class sq_Stack { private: int mm; int top; T*s; public: sq_Stack(int);//构造函数 ~sq_Stack();//析构函数 void prt_sq_S
栈的数学性质（Catalan函数）
github_36098115的博客
10-05 1万+
当n个编号元素以某种顺序进栈，并可在任意时刻出栈，所获得的编号元素排列的数目N恰好满足Catalan函数的计算，即N=C(2n,n)/(n+1)。   卡特兰数又称卡塔兰数，是组合数学中一个常出现在各种计数问题中的数列。以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)的名字来命名。   卡特兰数的前几项：1,1,2,5,14,42,132,429,1430,4862…  
公式解析（Stack栈类）
汉南最後の読書人
03-02 1349
题目要求： 在某些应用中，为了支持灵活性，往往用到自定义的公式。 比如，有如下的原始公式集合： int add(int x, int y):  返回x与y的和              int add(int x, int y, int z):  返回x,y,z三个数的和 int min(int x, int y):  返回x,y中较小的值 int max(int x, int y
包含main函数的栈
wl_ss的博客
12-28 978
题目描述 定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。 #include class Solution { public:     stack m_data, m_min;            void push(int value) {         m_data.push(value);         if(m_min.size() == 0 || m
java数据结构栈的所有操作以及主函数
gaoweiyuan1996的博客
09-25 907
package 算法.栈结构; import java.util.Scanner; class Data { String name; int age; } class StackType { //准备数据 static final int Maxlen=50; Data data[]=new Data[Maxlen+1]; int to...
用栈实现一般公式的解析器（中级版）
Eric的博客
03-16 675
用栈实现一般公式的解析器： 1、采用栈来进行出栈运算，运算值再入栈的方法。 2、支持小数点，负数的运算。 3、接收参数可以是一个全部数字的公式，也可以是一个包含变量的公式，另外一个参数就是公式里面的参数对应key,values的Map，key是变量名，value是变量的值。 优化点： 4、在// 处理公式，对于负数的前面补0formula = formula.replaceAll("...
初始化栈的代码_数据结构中的栈，你知道多少？
weixin_39927378的博客
10-21 243
由于栈比较简单，也很容易理解，学过的人都知道一句话就可以描述栈的特性：后进先出。所以这篇文章主要是写如何使用代码来描述栈，当然也是让大家很容易理解的语言。还是先给出这篇文章的大致脉络。首先，对栈有一个基本认识接下来，用代码实现栈，以及栈的常用操作然后，介绍栈的几种应用场景最后，小结一下。OK，开始。一、初识栈栈其实就是一个后进先出的线性表。就好比有很多辆车进了一个死胡同，第一进去的，总是最后一个出...
数据结构-顺序栈的基本操作的实现（含全部代码）
热门推荐
关注网络安全、云原生安全
09-15 7万+
主要操作函数如下： InitStack(SqStack &s) 参数：顺序栈s 功能：初始化 时间复杂度O(1) Push(SqStack &s,SElemType e) 参数：顺序栈s,元素e 功能：将e入栈 时间复杂度:O(1) Pop(SqStack &s,SElemType &e) 参数：顺序栈s,元素e 功能：出栈,e接收出...
数据结构试验——栈的基本操作
最新发布
10-07
栈是一种具有特定操作顺序的线性数据结构，遵循"后进先出"（Last In First Out，LIFO）的原则。栈的基本操作包括初始化、入栈、出栈、输出、销毁、置栈空、求栈长、判顺序栈是否为空、栈满以及取栈顶元素。 初始化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值