C++数据结构___栈

最新推荐文章于 2022-04-18 23:09:34 发布
最新推荐文章于 2022-04-18 23:09:34 发布
阅读量285 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43763999/article/details/107212588
版权

栈

数据结构探险—栈篇
在这里插入图片描述
C++实现栈记录

MyStack.h

#pragma once
#include<iostream>
using namespace std;


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;//栈顶，栈中元素个数
};

MyStack.cpp

#include"MyStack.h"

//初始化
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)//if(m_iTop == 0)//区别赋值
	{
		return true;
	}
	return false;
}

//判断栈满
bool MyStack::stackFull()
{
	if (m_iTop == m_iSize)//>=
	{
		return true;
	}
	return false;
}

//清空栈
void MyStack::clearStack()
{
	m_iTop = 0;
}

//已有元素的个数
int MyStack::stackLength()
{
	return m_iTop;
}

//元素入栈，栈顶上升
bool MyStack::push(char elem)
{
	if (stackFull())
	{
		return false;
	}
	m_pBuffer[m_iTop] = elem;
	m_iTop++;
	return true;
}

//元素出栈，栈顶下降
bool MyStack::pop(char& elem)
{
	if (stackEmpty())
	{
		return false;
	}
	m_iTop--;
	elem = m_pBuffer[m_iTop];
	return true;
}

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

//遍历栈中所有元素
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] << ",";
		}
	}
	
}

demo.cpp

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


int main()
{
	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();

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

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

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

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

改造后

Coordinate.h

#pragma once
#include<iostream>
using namespace std;


class Coordinate
{
public:
	Coordinate(int x, int y);
	void printCoordinate();
private:
	int m_iX;
	int m_iY;
};

Coordinate.cpp

#include"Coordinate.h"

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


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

MyStack.h修改

public:
    bool push(Coordinate elem);//元素入栈，栈顶上升
	bool pop(Coordinate& elem);//元素出栈，栈顶下降
private:
	Coordinate* m_pBuffer;//占空间指针

MyStack.cpp修改

//初始化
MyStack::MyStack(int size)
{
	m_iSize = size;
	//m_pBuffer = new char[size];
	m_pBuffer = new Coordinate[size];
	m_iTop = 0;
}

//元素入栈，栈顶上升
//bool MyStack::push(char elem)
bool MyStack::push(Coordinate elem)
{
	if (stackFull())
	{
		return false;
	}
	m_pBuffer[m_iTop] = elem;
	m_iTop++;
	return true;
}

//元素出栈，栈顶下降
//bool MyStack::pop(char& elem)
bool MyStack::pop(Coordinate& elem)
{
	if (stackEmpty())
	{
		return false;
	}
	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();
		}
	}
	
}

demo.cpp

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


int main()
{
	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;
}

高级—类模板

将普通栈改造为类模板栈，使其可以适用于任何数据类型

MyStack.h

#pragma once
#include<iostream>
using namespace std;

template<class 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<class T>
MyStack<T>::MyStack(int size)
{
	m_iSize = size;
	//m_pBuffer = new char[size];
	//m_pBuffer = new Coordinate[size];
	m_pBuffer = new T[size];
	m_iTop = 0;
}

//析构函数
template<class T>
MyStack<T>::~MyStack()
{
	delete[] m_pBuffer;
}

//判断栈是否为空
template<class T>
bool MyStack<T>::stackEmpty()
{
	if (0 == m_iTop)//if(m_iTop == 0)//区别赋值
	{
		return true;
	}
	return false;
}

//判断栈满
template<class T>
bool MyStack<T>::stackFull()
{
	if (m_iTop == m_iSize)//>=
	{
		return true;
	}
	return false;
}

//清空栈
template<class T>
void MyStack<T>::clearStack()
{
	m_iTop = 0;
}

//已有元素的个数
template<class T>
int MyStack<T>::stackLength()
{
	return m_iTop;
}

//元素入栈，栈顶上升
template<class T>
bool MyStack<T>::push(T elem)
{
	if (stackFull())
	{
		return false;
	}
	m_pBuffer[m_iTop] = elem;
	m_iTop++;
	return true;
}

//元素出栈，栈顶下降
template<class T>
bool MyStack<T>::pop(T& elem)
{
	if (stackEmpty())
	{
		return false;
	}
	m_iTop--;
	elem = m_pBuffer[m_iTop];
	return true;
}

//遍历栈中所有元素
template<class T>
void MyStack<T>::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];
		}
	}
}

Coordinate.h

#pragma once
#include<iostream>
using namespace std;

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

Coordinate.cpp

#include"Coordinate.h"

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

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

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

demo.cpp

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


int main()
{
	MyStack<Coordinate> *pStack = new MyStack<Coordinate>(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;
}

栈应用–进制转换

demo.cpp

#include <iostream>
#include "stdlib.h"
#include "MyStack.h"
#include "Coordinate.h"

using namespace std;

/*************************************************************************/
/*
	栈应用——数制转换
	描述：输入任意的十进制正整数N，分别输出该整数N的二进制、八进制、十六进制的数
	公式：N=(N div d) * d + N mod d (div表示整除，mod表示求余)
	(1348)(十进制) = (2504)(八进制) = (544)(十六进制) = (10101000100)(二进制)
	短除法
			N				N div 8		N mod 8
			1348		168				4
			168			21				0
			21			2					5
			2				0					2

			N				N div 16		N mod 16
			1348		84				4
			84			5					4
			5				0					5

			目的：通过实例灵活掌握栈机制的使用技巧
	
	*/
/*************************************************************************/

#define BINARY					2
#define OCTONARY			8
#define HEXADECTMAL		16
int main(void)
{
	MyStack<int> *pStack = new MyStack<int>(30);

	int N = 1348;
	int mod = 0;

	while (N != 0)
	{
		mod = N % OCTONARY;
		pStack->push(mod);
		N = N / OCTONARY;
	}

	pStack->stackTraverse(false);
	delete pStack;
	pStack = NULL;
	system("pause");
	return 0;
}

对于十六进制还需改进：

demo.cpp

#define BINARY					2
#define OCTONARY			8
#define HEXADECTMAL		16
int main(void)
{
	char num[] = "0123456789ABCDEF";
	MyStack<int> *pStack = new MyStack<int>(30);

	int N = 2016;
	int mod = 0;

	while (N != 0)
	{
		mod = N % HEXADECTMAL;
		pStack->push(mod);
		N = N / HEXADECTMAL;
	}

// 	pStack->stackTraverse(false);
	
// 	for (int i = pStack->stackLength() - 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"
#include "Coordinate.h"

using namespace std;

/*************************************************************************/
/*
	栈应用——括号匹配
	描述：任意输入一组括号，可以判断括号是否匹配
	字符串示例：[()]		[()()]		[()[()]]		[[()]
	目的：通过实例灵活掌握栈机制的使用技巧
	*/
/*************************************************************************/

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;
	pNeedStack = NULL;

	system("pause");
	return 0;
}
小呆@
关注
专栏目录
快速入门之C++栈、队列的使用，并初探深度优先搜索（DFS）和广度优先搜索（BFS）学习总结
皮卡丘LIII的博客
04-26 538
写在前面 最近开始学习算法，备战算法比赛。以下是我对栈和队列，以及运用栈和队列初探深度优先搜索（DFS）和广度优先搜索(BFS） C++栈的基本使用 栈遵循FILO原则，也就是先进后出。也可以被理解成LIFO，也就是后进先出 C++中 stack 头文件有他的具体实现，这里只是讲讲怎么简单的去运用它 ，其中stack.top()只是显示栈顶并不弹出，要用stack.pop()来弹出 #includ...
C/C++语言之链栈（初始化，入栈，遍历，查找）
Metaphysics的博客
11-13 5539
链式栈 定义：用链式存储结构实现的栈 实现：单链表（通常） 结点类型：同单链表结点 操作在栈顶，常不设头结点 链栈操作 运算受限的单链表 易于实现，不作详细讨论 特点 链栈无栈满问题 链表头在栈顶        源代码： #include &lt;stdio.h&gt; #include &l...
单调栈C++实现-查找数组中某个数左右两边离他最近小于他的数
effort_study的博客
02-01 1195
单调栈 给出一个数组，求助每个位置上的数，左边比他小的和右边比他小的数，常规的方法时间复杂度是O(N^2)，利用单调栈结构可以用O(N)解决上述问题。 单调栈实现（无重复数） 设置一个栈，栈底到栈顶从小到大，按照顺序将数据压入栈中，如某个数压入时不满足此时的大小顺序要求，就需要将栈中的数弹出，此时记录这个数的左右情况，右边比这个数小的是当前准备压入的这个数，左边比他小的这个数是栈中当前数压着的那个。 当数组压完以后，栈中有剩余，则依次弹出，右边比当前数小的不存在，左边比当前数小的是栈中他压着的那个 代码实现
C++数据结构链栈的初始化、元素进栈、出栈、判断是否为空
gsrkuang的博客
11-01 2023
初始化等操作链栈的学习记录 #include <stdio.h> #include <stdlib.h> #include "stdafx.h" #include "iostream" using namespace std; #define OK 1 #define ERROR 0 typedef char SElemType; //栈的链式储存结构 typedef ...
C++栈实现
Shirven
04-28 2129
1、栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守“先进后出"(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。 2、栈的相关概念： （1）栈顶与栈底：允许元素插入与删除的一端称为栈顶，另一端称为栈底。 （2）压栈：栈的插入操作，叫做进栈，也称压栈、入栈。 （3）弹栈：栈的删除操作，也叫做出栈。 ...
数据结构_基于C++数据结构源码_数据结构_silent2pg_
09-29
"silent2pg"可能是这个项目或者作者的代号，而"基于C++数据结构源码_数据结构_silent2pg_"这个标题暗示了这是一个包含C++实现的各种数据结构的代码库。 在C++中，常见的数据结构包括数组、链表、栈、队列、树、图等...
huffman树_Huffman树_C++_huffman_数据结构_
10-02
哈夫曼树（Huffman Tree），也称为最优二叉树，是数据压缩中常用的一种数据结构。它是一种带权路径长度最短的二叉树，由哈夫曼在1952年提出，用于解决“最小带权路径长度”问题。在哈夫曼树中，频率较高的字符对应的...
zx.rar_数据结构_C++_Builder_
08-11
《数据结构与C++ Builder实现详解》 在计算机科学领域，数据结构是组织、管理和存储数据的方式，它为数据的高效处理提供了基础。C++ Builder是一款集成开发环境，结合了C++的强大编程能力和Visual Component ...
队列实现栈_栈_数据结构_队列_
09-30
栈和队列是两种基本且常用的数据结构，它们各有各的特点和应用场景。本篇将重点讨论如何利用队列来实现栈的功能，以及这两种数据结构在实际问题中的应用。 栈是一种后进先出（LIFO，Last In First Out）的数据结构...
JS.rar_数据结构_C++_Builder_
08-11
常见的数据结构包括数组、链表、栈、队列、树、图等。在解决实际问题时，选择合适的数据结构能显著提高算法的性能。例如，堆可以用来实现优先队列，这对于实现贪心算法求解最小生成树或最短路径问题非常有用。 **...
c++ 基本的查找算法
xuefujin的博客
03-26 1943
顺序查找－比较简单，循环比较即可[cpp] view plain copy/*Find*/  //顺序查找算法,循环比较即可  #include &lt;iostream&gt;  #include &lt;time.h&gt;  #define N 15  using namespace std;  int Search(int a[],int n,int key)  {      int i,...
学习C++数据结构（栈的实现）
邱小兵的博客
02-26 549
在学习数据结构的时候自己纯手打的实现代码，放到平台上来方便自己日后回顾，也可以给其他想学习的朋友一点小小的参考。 （代码思路来源于慕课网的c++数据结构课程） MyStack.h #pragma once #include<iostream> #include<string> #include<stdlib.h> using namespace std; ...
10-C++实现栈的常见操作
Hello Code
08-22 2195
栈分为顺序栈和链栈，顺序栈用数组实现，因为栈的先进后出特性，一般只考虑顺序栈。 代码1（自己写的）： #include &lt;iostream&gt; #include &lt;stdio.h&gt; #define ERR -9999999 const int maxn = 1000; using namespace std; typedef struct Stack{ in...
获取栈中任意位置的元素
harry-lin的博客
07-14 6098
public int getElement(Stack&lt;Integer&gt; stack, int position) { int result = stack.pop(); if (stack.size() == position) { // stack.push(result); re...
C++数据结构---栈
Rookie_Ws的博客
04-18 866
stack.h #pragma once #include<iostream> using namespace std; class Mystack { public: Mystack(); //打印栈中的数据（从栈顶到栈底） void Mystack::m_print(); //在栈顶添加元素 void m_push(int val); //从栈顶移除第一个元素 void m_pop(); //返回栈顶元素 int m_top(); //判断堆栈是否为空 bool
在列表中查找列表并取出元素-1
weixin_30752699的博客
09-27 1215
举例：var_list 是一个多层嵌套列表 var_list = [1,2,[3,4,[5,6,7,[8,9]]]] 试试for循环来遍历列表中的元素吧 >>> for var in var_list: print(var) 　　　　print(var) 1 2 [3, 4, [5, 6, 7, [8, 9]]] 结果好像不是我们想要的那样，试试这样。 v...
栈的应用——深度优先搜索（走迷宫）
chenchen_fcj程序猿的博客
07-28 977
栈应用到走迷宫（寻路算法）的做法 迷宫就是下图所示的这种，这次主要是先用代码画出一个迷宫（利用二维数组），然后寻路走到出口 代码如下：(在C++中运行) mystack.h #include&lt;stdlib.h&gt; #include&lt;stdio.h&gt; struct Point  //这个就是显示的坐标点位置，其余都一样，只是data的类型变了，变为坐标 {    ...
C++ 栈的基本操作
weixin_33859504的博客
12-14 1172
1 // zhan.cpp : 定义控制台应用程序的入口点。 2 // 3 4 #include "stdafx.h" 5 #include <iostream> 6 using namespace std; 7 typedef struct stacknode 8 { 9 int data; 10 stru...
leecode-栈小结(1)
ProGramming_Mk的博客
10-20 514
Leecode栈刷题小结一、基本语法二、题目leecode-20 有效的括号(简单)leecode-71 简化路径(中等)leecode-84. 柱状图中最大的矩形(困难)739. 每日温度94. 二叉树的中序遍历103. 二叉树的锯齿形层次遍历150. 逆波兰表达式求值2.读入数据总结 一、基本语法 获取Stack对象 Stack<Character> stack=new Stack<>(); 入栈 stack.push(ch); 出栈，栈为空时会抛出异常 cha
C++实现通讯录数据结构项目分析
在C++中，有多种数据结构可供选择，例如数组、链表、栈、队列、树和图等。对于通讯录程序来说，链表是一个非常合适的选择，因为它可以动态地存储任意数量的联系人信息，并且在插入和删除操作上具有良好的性能。 一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值