数据结构——stack的实现

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

一、定义

       栈stack是一种限定在仅仅只能在尾部进行插入删除的线性表。允许进行插入删除的一端叫做栈顶，而另一端就叫做栈底。

二、栈的分类

1. 顺序栈：所有操作的时间复杂度均为O（1）；

2. 共享栈：两个栈共享一段空间向中间靠拢；

3. 链式栈：它的Push和Pop操作是头插法。

三、栈的模拟实现

在其中我还运用了类型萃取。

#include<cassert>
#include<iostream>
using namespace std;

struct _TrueType
{
	bool Get()
	{
		return true;
	}
};

struct _FalseType
{
	bool Get()
	{
		return false;
	}
};

template<class _Tp>
struct TypeTraits
{
	typedef _FalseType _IsPODType;
};

template<>
struct TypeTraits<char>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<bool>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<int>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<unsigned char>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<short>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<unsigned short>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<unsigned int>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<long>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<unsigned long>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<long long>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<unsigned long long>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<double>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<long double>
{
	typedef _TrueType _IsPODType;
};

template<>
struct TypeTraits<float>
{
	typedef _TrueType _IsPODType;
};


class Date
{
public:
	Date(int year = 1990, int month = 1, int day = 1);
	friend ostream& operator<< (ostream& out, const Date& d);
	Date operator+(int days);//返回一个值是因为不想改变当前的日期，
	Date operator-(int days);
	int operator-(const Date& d); //两个日期相减，两者差多少天。
	Date& operator++();  //重载前置++。
	Date operator++(int); //重载后置++。
	Date& operator--(); //重载前置--。
	Date operator--(int);  //重载后置--。
	bool operator<(const Date& d);//重载<
	bool operator>(const Date& d);//重载>
	bool operator<=(const Date& d);//重载<=
	bool operator>=(const Date& d);//重载>=
	bool operator==(const Date& d);//重载==
	bool operator!=(const Date& d); //重载!=
private:
	bool IsLeapYear(int year)
	{
		if ((year % 400 == 0) || (year % 4 == 0) && (year % 100 != 0))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	int GetMonthInDay(int year, int month)   //得到每一个月的天数。
	{
		char days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
		if (IsLeapYear(year) && (month == 2))
		{
			days[month]++;
		}
		return days[month];
	}
private:
	int m_year;
	int m_month;
	int m_day;
};


Date::Date(int year, int month, int day) :m_year(year), m_month(month), m_day(day)
{
	if (!((year > 0) && ((month > 0) && (month < 13)) && ((day>0) && (day <= GetMonthInDay(year, month))))) //输入的日期不合法，将日期设置为默认值
	{
		m_year = 1900;
		m_month = 1;
		m_day = 1;
	}
}
ostream& operator<< (ostream& out, const Date& d)
{
	out << d.m_year << "--" << d.m_month << "--" << d.m_day;
	return out;
}

Date Date:: operator+(int days)
{
	if (days < 0)
	{
		return ((*this) - (0 - days));
	}

	Date temp(*this);  //创建一个变量是因为在这个变量中操作要操作的东西，防止将原来的数据改变了。
	temp.m_day += days;  //将当前的天数+要加的天数。
	while (temp.m_day > GetMonthInDay(temp.m_year, temp.m_month))
	{
		temp.m_day -= GetMonthInDay(temp.m_year, temp.m_month);   //减去当前月的天数。
		if (temp.m_month == 12)
		{
			temp.m_month = 1;
			temp.m_year++;
		}
		else
		{
			temp.m_month++;
		}
	}
	return temp;
}

Date Date:: operator-(int days)
{
	if (days < 0)
	{
		return ((*this) + (0 - days));
	}
	Date temp(*this);
	temp.m_day -= days;
	while (temp.m_day <= 0)
	{
		if (temp.m_month == 1)
		{
			temp.m_month = 12;
			temp.m_year--;
		}
		else
		{
			temp.m_month--;
		}
		temp.m_day += GetMonthInDay(temp.m_year, temp.m_month);  //加上上一个月的天数。使得天数为真。
	}
	return temp;  //返会一个临时变量，对真正的变量并未改动。

}

Date& Date:: operator++()  //重载前置++。
{
	(*this) = (*this) + 1;  //将临时对象的值赋值给这个正在操作的对象。
	return *this;
}
Date Date::operator++(int)//重载后置++。
{
	Date temp(*this);
	(*this) = (*this) + 1;
	return temp;
}

Date& Date:: operator--() //重载前置--。
{
	(*this) = (*this) - 1;
	return *this;
}

Date Date:: operator--(int)  //重载后置--。
{
	Date temp(*this);
	(*this) = (*this) - 1;
	return temp;
}

int Date::operator-(const Date& d)
{
	Date maxDate(*this);
	Date minDate(d);

	if (minDate > maxDate)
	{
		swap(minDate, maxDate);
	}

	int count = 0;
	while (minDate < maxDate)
	{
		count++;
		minDate++;
	}
	return count;

}

bool Date::operator<(const Date& d)//重载<
{
	return ((m_year < d.m_year) || ((m_year == d.m_year) && (m_month < d.m_month))
		|| ((m_year == d.m_year) && (m_month == d.m_month) && (m_day < d.m_day)));
}

bool Date:: operator>(const Date& d)//重载>
{
	/*if (*this < d || *this == d)
	{
	return false;
	}
	else
	{
	return true;
	}*/
	return  (!(*this < d) && !(*this == d));
}

bool Date:: operator<=(const Date& d)//重载<=
{
	return !(*this>d);

}

bool Date:: operator>=(const Date& d)//重载>=
{
	return !(*this < d);

}

bool Date:: operator==(const Date& d)//重载==
{
	return (m_year == d.m_year  && m_month == d.m_month && m_day == d.m_day);

}

bool Date:: operator!=(const Date& d) //重载！=
{
	return !(*this == d);

}



template<class S>
class Stack
{
public:
	Stack<S>()
		: pdata(new S[5])
		, size(0)
		, capacity(5)
	{}

	bool Empty()const
	{
		return 0 == size;
	}

	void Push(const S& data)//栈的数据插入只能在栈顶进行
	{
		Checkapacity();//检测容量
		pdata[size] = data;
		size++;
	}

	void Pop()
	{
		assert(!Empty());
		size--;
	}

	S& Top()
	{
		return pdata[size - 1];
	}

	size_t Size()
	{
		return size;
	}

	~Stack<S>()
	{
		if (pdata)
		{
			delete[] pdata;
			pdata = NULL;
			size = 0;
			capacity = 0;
		}
	}

	Stack<S>(const S& s)
		: pdata[new S[s.capacity]]
		, size(s.size)
		, capacity(s.capacity)
	{
		cout << "Type" << ": " << typeid(S).name() << endl;
		if (TypeTraits<S>::_IsPODType().Get())
		{
			memcpy(pdata, s.pdata, s.size);
		}
		else
		{
			for (int i = 0; i < size; i++)
			{
				pdata[i] = s.pdata[i];
			}
		}
	}

	Stack<S>& operator=(const S& s)
	{
		cout << "Type" << ": " << typeid(S).name() << endl;
		if (this != &s)
		{
			if (capacity < s.size)
			{
				S *ptemp = new S[s.capacity];
				delete pdata;
				pdata = ptemp;
				capacity = s.capacity;
			}
			if (TypeTraits<S>::_IsPODType().Get())
			{
				memcpy(pdata, s.pdata, s.size);
			}
			else
			{
				for (int i = 0; i < s.size; i++)
				{
					pdata[i] = s.pdata[i];
				}
			}
			size = s.size;
		}
		return *this;
	}

	void Print()
	{
		for (size_t i = 0; i < size; i++)
		{
			cout << pdata[i] << " ";
		}
		cout << endl;
	}

private:
	S *pdata;
	size_t size;//有效数据个数
	size_t capacity;//栈的容量

	void Checkapacity()//检测栈的容量——申请新的空间，拷贝原空间的数据，析构原来的空间
		//（类型萃取分清数据是内置类型还是自定义类型）
	{
		cout << "Type" <<": "<<typeid(S).name() << endl;
		if (size >= capacity)
		{
			S* ptemp = NULL;
			ptemp = new S[capacity * 2];//申请新空间
			if (TypeTraits<S>::_IsPODType().Get())
			{
				memcpy(ptemp, pdata, size);//memcpy可能会导致浅拷贝的问题，但是它的效率高于循环
			}
			else
			{
				for (size_t i = 0; i < size; i++)
				{
					ptemp[i] = pdata[i];//循环拷贝数据，虽然慢但是安全
				}
			}
			delete[] pdata;//析构原来的空间
			pdata = ptemp;
			capacity = capacity * 2;
		}
	}
};

int main()
{
	Date d1(2017, 1, 1);
	Date d2(2017, 1, 2);
	Date d3(2017, 1, 3);
	Stack<Date> s;
	/*s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	s.Print();*/

	s.Push(d1);
	s.Push(d2);
	s.Push(d3);

	//s.Pop();
	//s.Print();
	/*int a=s.Top();
	cout << a << endl;*/

	Stack<Date> a(s);
	a.Print();

	/*Stack<int> a;
	a = s;
	a.Print();*/

	system("pause");
	return 0;
}

四、栈的应用

#include<stack>
#include<iostream>
using namespace std;

//1、括号匹配问题
//char a[] = "(())abc{[(])}"; // 左右括号次序匹配不正确
//char b[] = "(()))abc{[]}"; // 右括号多于左括号
//char c[] = "(()()abc{[]}"; // 左括号多于右括号
//char d[] = "(())abc{[]()}"; // 左右括号匹配正确

bool IsBracket(char c)//判断是不是括号，如果不是括号不用入栈
{
	if (c == '(' || c == ')' ||
		c == '[' || c == ']' ||
		c == '{' || c == '}')
	{
		return true;
	}
	return false;
}

bool Match(char *str, size_t size)
{
	std::stack<char> S;
	for (size_t idx = 0; idx < size; idx++)
	{
		if (!IsBracket(str[idx]))
		{
			continue;
		}
		else
		{
			if (str[idx] == '(' || str[idx] == '[' || str[idx] == '{')
			{
				S.push(str[idx]);
				continue;
			}
			if (S.empty())//相当于第一个是右括号入栈而不是左括号，第一次就匹配失败
			{
				cout << "右括号比左括号多" << endl;
				return false;
			}
			char ctop = S.top();
			if (((ctop == '(') && (str[idx] == ')')) ||
				((ctop == '[') && (str[idx] == ']')) ||
				((ctop == '{') && (str[idx] == '}')))
			{
				S.pop();
			}
			else
			{
				cout << "左右括号次序不匹配" << endl;
				return false;
			}
		}
	}
	if (S.empty())//当所有的元素都扫描完毕，此时的栈已经为空，说明括号全部匹配
	{
		cout << "匹配成功" << endl;
		return true;
	}
	else
	{
		cout << "左括号比右括号多" << endl;
		return false;
	}
}

int main()
{
	char a[] = "(())abc{[(])}"; // 左右括号次序匹配不正确
	char b[] = "(()))abc{[]}"; // 右括号多于左括号
	char c[] = "(()()abc{[]}"; // 左括号多于右括号
	char d[] = "(())abc{[]()}"; // 左右括号匹配正确
	cout<<Match(a, strlen(a))<<endl;
	cout<<Match(b, strlen(b))<<endl;
	cout<<Match(c, strlen(c))<<endl;
	cout<<Match(d, strlen(a))<<endl;
	system("pause");
	return 0;
}


#include<stack>
#include<iostream>
using namespace std;
//2.逆波兰表达式——把中缀表达式转换为后缀表达式
//12 * (3 + 4) - 6 + 8 / 2 == > 12 3 4 + *6 - 8 2 / +

enum Operator
{
	ADD,
	MUL,
	SUB,
	DIV,
	DATA
};

struct Cell
{
	Operator _opeator;
	int _data;
};

int CalcRPN(Cell cell[], size_t size)
{
	stack<int> S;
	for (size_t idx = 0; idx < size; idx++)
	{
		if (cell[idx]._opeator == DATA)//如果是数字就入栈
		{
			S.push(cell[idx]._data);
		}
		else
		{
			int right = S.top();//每次取出栈顶的两个数字进行计算
			S.pop();
			int left = S.top();
			S.pop();
			switch (cell[idx]._opeator)
			{
			case ADD:
				S.push(left + right);
				break;
			case MUL:
				S.push(left * right);
				break;
			case SUB:
				S.push(left - right);
				break;
			case DIV:
				if (right == 0)
				{
					return -1;
				}
				S.push(left / right);
				break;
			default:
				cout << "没有相关运算" << endl;
			}
		}
	}
	return S.top();
}

int main()
{
	struct Cell cell[] = { { DATA, 12 }, { DATA, 3 }, { DATA, 4 }, { ADD, 0 }, { MUL, 0 },
	{ DATA, 6 }, { SUB, 0 }, { DATA, 8 }, { DATA, 2 }, { DIV, 0 }, { ADD, 0 } };
	int a = CalcRPN(cell, sizeof(cell) / sizeof(cell[0]));
	cout << a << endl;
	system("pause");
	return 0;
}




SMQsmq
关注
浅谈栈（Stack）数据结构
bc_Reversing的博客
04-28 1667
一、概述： 栈（stack）：栈是一种线性的结构，这种数据结构仅限在线程表的一段进行插入和删除操作。其中线性表插入的和删除的一段称为栈顶（top），不循序插入和删除的一段称为栈底（bottom）。所以栈数据结构是遵循“后入先出”，也就是“LIFO”。 二、栈的特征 （1）栈也是一种线性的机构。 （2）相比较数组，占对应的操作是数组的子集。 （3）只能从一端添加元素，也只能从一端取出元素，这一端称为栈顶。 （4）栈是一种后进先出的数据结构。称为：Liast In First Out（LIFO）
数据结构之栈stack
沉默的二毛的博客
11-25 2415
数据结构之栈stack 什么是栈？ 栈的基本特点 栈是如何工作的 栈的实现 栈的应用 什么是栈？ 栈是一种“后进先出”（LIFO）的线性数据结构，是一种特殊的线性表。 栈的基本特点 在栈中，元素的添加和删除操作只能在表的一端进行，即栈顶。 元素的添加和删除遵循“后进先出”（LIFO）的原则，最后添加的元素总是最先出栈 栈对元素的访问加以限制，仅仅提供对栈顶元素的访问操作 栈是如何
基本数据结构：栈（stack）
weixin_30384031的博客
08-13 495
基本数据结构：栈（stack） 作者：C小加更新时间：2012-8-1 栈（stack）是限制插入和删除只能在一个位置上进行的线性表，该位置在表的末端，叫做栈顶。添加元素只能在尾节点后添加，删除元素只能删除尾节点，查看节点也只能查看尾节点。添加、删除、查看依次为入栈（push）、出栈（pop）、栈顶节点（top）。形象的说，栈是一个先进后出（LIFO）表，先进去的节点要等到后边进去的节点出来...
数据结构——栈（Stack）
最新发布
脑壳有点痒，好像要长脑子了！
08-10 950
栈是一种线性表（俗称堆栈），它限制只能在一端（称为栈顶）进行插入和删除操作，另一端（称为栈底）是固定的，不允许进行插入和删除操作，栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针，当栈中没有元素时称为“空栈”。最大特点 ：后进先出（LIFO）。
数据结构系列之Stack
weixin_41909603的博客
09-30 529
本期文章介绍的是另一种数据结构Stack。 Stack的主要特征有两个，分别是：(1) 是一种抽象数据结构。抽象的数据结构在上期文章(https://blog.csdn.net/weixin_41909603/article/details/101525345)中已介绍，在此不赘述。(2) LIFO，即Last In First Out，指的是在Slack中删除元素时，最后被添加进Slack的元素...
Stack (数据结构） note
mygodhome的专栏
01-20 386
Stack&lt;Character&gt; stackS = new Stack();         int a = stackS.size(); int java.util.Vector.size() Returns the number of components in this vector. Specified by: size() in List, Overrides: si...
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
数据结构——利用 Stack类 为其设计外部函数 delete_all功能
12-24
void delete_all(Stack<T> &s, const T &x)——删除栈s中所有等于x的数据项，保持其他数据项顺序不变。 输入：input.txt，其第一个字符为x，其后按栈底到栈顶的顺序依次给出栈中字符，字符间用空格、回车或制表符...
Java数据结构——Stack和父类Vector
Willis'
06-27 975
分析Stack操作数据的方法，并分析Vector与ArrayList的不同之处。
C++实现的任意进制转换（数据结构——栈和队列）
08-10
在实现过程中，可以使用标准库中的`std::stack`和`std::queue`来创建和管理数据结构，`std::stringstream`用于数字和字符串之间的转换，以及`std::pow`来计算基数的幂次。此外，利用C++的模板功能，可以让这个转换...
数据结构——Stack
zhangquanit的专栏
08-02 604
java的数据结构——栈
数据结构（Stack栈）
weixin_45638349的博客
09-03 266
数据结构之——Stack （栈） 1，栈的定义 栈：先进后出的数据结构，如下图所示，先进去的数据在底部，最后取出，后进去的数据在顶部，最先被取出。 栈常用操作： s=Stack() 创建栈 s.push(item) 将数据item放在栈的顶部 s.pop() 返回栈顶部数据，并从栈中移除该数据 s.peek() 返回栈顶部数据，但不移除 s.size() 返回栈的大小 s.isEmpty() 返回栈是否
数据结构之Stack
weixin_52804129的博客
10-22 205
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、Stack的基本概念二、使用步骤1.引入库2.读入数据总结 一、Stack的基本概念 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warn
数据结构__stack
chaoyueziji123的专栏
02-24 809
栈的定义及基本运算 1、栈的定义     　栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。 　　(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。 　　(2)当表中没有元素时称为空栈。 　　(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。     　栈的修改是按后进先出的原则进行。每次删除（退栈）的总
数据结构 - 栈(Stack)
张大安的博客
04-30 2754
文章目录栈的介绍用数组模拟栈栈实现计算器 栈的介绍 栈的英文为(stack)。 栈是一个先入后出(FILO : First In Last Out)的有序列表。 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊的线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）。 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶；而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 入栈(push)示
数据结构 -- 栈（Stack）
qq_41217625的博客
11-23 403
一、栈的简介 定义 栈（stack）又称为堆栈或堆叠，栈作为一种线性数据结构，按照先进后出的原则存储数据。先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。 由于堆叠数据结构只允许在一段进行操作，因而按照后进先出（LIFO == Last In First Out）的原理运作。栈也称后进先出表。 栈的应用场景...
数据结构——栈(stack)
qq_64191695的博客
07-06 1005
栈(stack) 1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2.处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3.表达式的转换【中缀表达式转后缀表达式】和求值。 4.二叉树的遍历 5.图形的深度优先搜索法栈代码实现（数组）： 输出结果： 栈实现计算器： 中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（上述代码有些冗杂）。因此，在计算结束时，往往会将中缀表达
stack（栈）数据结构详解
weixin_34037173的博客
04-26 756
栈（stack）的那些事 1.1栈的简介 栈作为一种限制性访问数据结构，提供了push（）压入和pop()弹出的方法，具有后进先出的特点，使得程序不容易出错。 关于栈的实现，输入的入栈和出栈的时间复杂度为O(1)。操作时间不依赖总体栈中的个数，因此操作时间非常快。 1.2 栈的Java实现 这里用底层数组用Object主要为了能存储不同对象，默认初始化数组大小为10，当push时候会先判断是否需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值