数据结构 | 栈（顺序栈+链栈）的基本实现

已于 2023-10-28 14:00:55 修改
阅读量271 收藏 2
点赞数 1
分类专栏： 数据结构与算法(C++) 文章标签： 数据结构 c++ 算法
于 2023-10-28 13:56:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68732914/article/details/134088874
版权

学习教材：王红梅《数据结构——从概念到C++实现》、严蔚敏《数据结构》

学习课程：青岛大学王卓《数据结构与算法基础》

分类专栏：数据结构与算法(C++)

目录

前言

正文

1.栈的介绍

1.1 栈的概述

1.2 栈的特点

2.栈的基本实现及设计

2.1 顺序栈设计

2.1.1 数据类型设计

2.1.2 算法设计

（1）构造函数

（2）析构函数

（3）入栈操作

（4）创建指定长度的顺序栈

（5）判空操作

（6）出栈操作

（7）取出栈顶元素（不删除）

（8）输出顺序栈长度

（9）遍历打印顺序栈当前元素

2.2 链栈设计

2.2.1 数据类型设计

2.2.2 算法设计

（1）构造函数

（2）析构函数

（3）入栈操作

（4）创建指定长度的链栈

（5）出栈操作

（6）输出链栈长度

（7）判空操作

（8）取出栈顶元素（不删除）

（9）遍历打印链栈当前元素

2.3 菜单设计

2.3.1 主页面菜单设计

2.3.2 二级页面菜单设计

3.全部代码(分文件编写)

SeqStack.h

SeqStack.cpp

LinkedStack.h

LinkedStack.cpp

my_Menu.h

my_Menu.cpp

main.cpp

前言

        最近刚在学习《数据结构与算法》，单纯地跟课、看书觉得并不能很好的掌握好这些知识点，所以决定尝试将学习的知识点归纳总结，也将其进行代码实现，强化对知识点的理解。即作为笔记、实践，又作为我的思路分享。因为初学，难免有不正确、不恰当之处，敬请指正！

正文

1.栈的介绍

1.1 栈的概述

        栈（stack）是限定仅在表的一端进行插入和删除操作的线性表，允许插入和删除的一端称为栈顶（stack top），另一端为栈底（stack bottom），不含任何数据元素的栈称为空栈。跟据存储结构的不同，栈同样可以分为顺序栈和链栈两种。

1.2 栈的特点

        栈可以理解为一种功能受限的线性表，因此栈中的元素同样具有线性关系。但因为其只能通过一端进行元素的插入和删除，入栈、出栈具有顺序性，因此栈还具有“后进先出”的特性。

        举个简单的例子：一把枪我们填入子弹后，如果要将最底下（也就是最先放入）的子弹取出来的话，我们需要把在它之后填入的子弹按照顺序取出，即“后进先出”。

2.栈的基本实现及设计

2.1 顺序栈设计

2.1.1 数据类型设计

        首先定义一个模板类SeqStack，其成员变量有两个，一个是存储数据的数组data，一个是存储顺序栈栈顶元素序号的变量top，为保证数据的安全性，均将权限设为私有。为实现数据的一系列操作，又创建了相应的成员函数，将其权限设置为公有，作为成员变量的接口，供测试者使用。

#define MAXSIZE 100 // 顺序栈最多可以存储多少个元素，可按要求更改

template<typename DataType>
class SeqStack
{
public:
	SeqStack();						// 构造函数，初始化一个空栈
	~SeqStack() {};					// 析构函数
	void CreateSeqStack();
	void Push(DataType x); 			// 入栈操作，将元素x入栈
	DataType Pop();					// 出栈操作，将栈顶元素弹出，并返回弹出的元素值
	DataType GetTop();				// 取出栈顶元素（并不删除）
	int Length();					// 求顺序栈长度
	int Empty();					// 判空操作
	void PrintStack();			    // 遍历打印，按照出栈顺序打印

private:
	DataType data[MAXSIZE];         // 存储元素的数据
	int top;                        // 存储栈顶元素的下标
};
2.1.2 算法设计
（1）构造函数

        即将顺序栈进行初始化，只需将栈顶指针top置为-1即可。

template<typename DataType>
SeqStack<DataType>::SeqStack()
{
	this->top = -1;
}
（2）析构函数

        顺序栈为静态存储分配，在顺序栈变量退出作用域时，将自动释放顺序栈所占存储空间，因此无须销毁，析构函数为空。

（3）入栈操作

       首先应判断栈是否为满，即top+1是否等于 MAXSIZE 。若未满， 在栈中插入元素n只需要将栈顶位置加1，然后在data[top]的位置填入元素x。

template<typename DataType>
void SeqStack<DataType>::Push(DataType x)
{
	if (this->top+1 == MAXSIZE) throw"上溢";
	this->data[top + 1] = x;
	this->top++;
}
（4）创建指定长度的顺序栈

        创建长度为n的顺序栈，即按照输入顺序，对一个空栈进行n次入栈。

template<typename DataType>
void SeqStack<DataType>::CreateSeqStack()
{
	int num, value;
	cout << "请输入要入栈的元素个数：";
	cin >> num;
	cout << "请输入要入栈的元素数值：";
	for (int i = 0; i < num; i++)
	{
		cin >> value;
		this->data[i] = value;
		this->top++;
	}
}
（5）判空操作

        判空操作只需要判断顺序栈类成员函数top是否等于-1，即 this->top==-1。

template<typename DataType>
int SeqStack<DataType>::Empty()
{
	if (this->top==-1)		
		return 1;
	else
		return 0;
}
（6）出栈操作

        将一个元素从顺序栈中删除，即出栈，首先应判断栈是否为空，即this->Empty（）是否等于1。若栈非空，出栈操作只需取出栈顶元素，然后top再减1。

template<typename DataType>
DataType SeqStack<DataType>::Pop()
{
	DataType y;
	if (this->Empty() == 1) throw"下溢";
	y = this->data[top];
	this->top--;
	return y;
}
（7）取出栈顶元素（不删除）

        取栈顶元素只是将top位置的栈顶元素取出并返回，并不改变栈本身。

template<typename DataType>
DataType SeqStack<DataType>::GetTop()
{
	DataType y;
	if (this->Length() == 0) throw"下溢";
	// if (this->Empty == 1) throw"下溢";
	y = this->data[top];
	return y;

}
（8）输出顺序栈长度

        输出顺序栈的长度，就是将top加1后再返回。

template<typename DataType>
int SeqStack<DataType>::Length()
{
	return this->top+1;
}
（9）遍历打印顺序栈当前元素

        通过前面所写的Length()，得到顺序栈的长度，使用循环，从栈底开始遍历打印。

template<typename datatype>
void SeqStack<datatype>::PrintStack()
{
	int length = this->Length();

	if (length > 0)
	{
		for (int i = 0; i < length; i++)
			cout <<this->data[i] << " ";
		cout << endl;
	}
	else
		cout << "顺序栈为空" << endl;
}

2.2 链栈设计

2.2.1 数据类型设计

        首先使用结构体创建LinkedNode数据类型，定义了结点，包括指针域next和数据域data。随后定义链栈类LinkedStack，其成员变量为LinkedNode类型的指针top，为保证数据的安全性，将权限设为私有。为实现数据的一系列操作，又创建了相应的成员函数，将其权限设置为公有，作为成员变量的接口，供测试者使用。

// 定义了LinkNode结点
template<typename DataType>
struct LinkNode {
	DataType data;//数据域
	LinkNode<DataType>* next;//指针域 
};

template<typename DataType>
class LinkedStack
{
public:
	LinkedStack() { top = NULL; }		// 构造函数，初始化一个空栈
	~LinkedStack();					// 析构函数
	void CreateLinkedStack();
	void Push(DataType x); 			    // 入栈操作，将元素x入栈
	DataType Pop();					    // 出栈操作，将栈顶元素弹出，并返回弹出的元素值
	DataType GetTop();				    // 取出栈顶元素（并不删除）
	int Length();					    // 求顺序栈长度
	int Empty();					    // 判空操作
	void PrintStack();		            // 遍历打印，按照出栈顺序打印

private:
	LinkNode<DataType>* top;
};
2.2.2 算法设计
（1）构造函数

        链栈不带头结点，初始化一个空链栈只需将栈顶指针top置空。

template<typename DataType>
LinkedStack<DataType>::LinkedStack()
 { 
    top = NULL; 
}
（2）析构函数

        链栈为动态存储分配，在链栈变量退出作用域前要释放链栈的存储空间。

template<typename DataType>
LinkedStack<DataType>::~LinkedStack()
{
	LinkNode<DataType>* p = top;
	while (this->top)
	{
		top = top->next;
		delete p;
		p = top;
	}
}
（3）入栈操作

        链栈的插入只需处理栈顶的情况，先申请一个新结点s，在其数据域中存入入栈元素、指针域存入top的地址，再使top=s。

template<typename DataType>
void LinkedStack<DataType>::Push(DataType x)
{
	// 申请一个数据域为x的结点s
	LinkNode<DataType>* s = new LinkNode<DataType>;
	if (!s)
	{
		cout << "分配内存失败";
		return;
	}
	s->data = x;
	s->next = top;
	top = s;
}
（4）创建指定长度的链栈

        创建长度为n的链栈，即按照输入顺序，对一个空链栈进行n次入栈。

template<typename DataType>
void LinkedStack<DataType>::CreateLinkedStack()
{
	this->top = nullptr;
	LinkNode<DataType>* s = nullptr;

	int num, value;
	cout << "请输入要创建的链栈长度：";
	cin >> num;
	cout << "请输入入栈的元素数值：";

	for (int i = 0; i < num; i++) 
	{
		cin >> value;
		LinkNode<DataType>* newNode = new LinkNode<DataType>;
		newNode->data = value;
		newNode->next = top;
		top = newNode;
	}
}
（5）出栈操作

        链栈的删除操作只需处理栈顶的情况，创建一个临时结点temp，使temp=top，将栈顶元素取出，随后使top=top->next，使栈顶指针top指向下一结点。将temp的数据域取出存于新定义的变量y中，随后释放结点temp（原栈顶元素）。

template<typename DataType>
DataType LinkedStack<DataType>::Pop()
{
	if (this->Empty() == 1) throw"下溢";

	LinkNode<DataType>* temp = top;
	top = top->next;
	int y = temp->data;
	delete temp;
	return y;
}
（6）输出链栈长度

        定义了变量length用于计数，在循环中遍历链栈，直至到栈底元素为止，判定的依据为结点的next域为空。

template<typename DataType>
int LinkedStack<DataType>::Length()
{
	int length = 0;
	LinkNode<DataType>* current = this->top;
	while (current != nullptr) {
		current = current->next;
		length++;
	}
	return length;
}
（7）判空操作

        使用前面所写的Length()函数进行判空。

template<typename DataType>
int LinkedStack<DataType>::Empty()
{
	if (this->Length() == 0)
	{
		return 1;
	}
	else
		return 0;
}
（8）取出栈顶元素（不删除）

        取栈顶元素只需返回栈顶指针top所指结点的数据域，并不修改栈顶指针。

template<typename DataType>
DataType LinkedStack<DataType>::GetTop()
{
	if (this->Empty() == 1) throw"下溢";

	return top->data;
}
（9）遍历打印链栈当前元素
template<typename DataType>
void LinkedStack<DataType>::PrintStack()
{
	LinkNode<DataType>* current = this->top;

	cout << "当前链表中的元素为：";
	while (current != nullptr) {
		cout << current->data << " ";
		current = current->next;
	}
	cout << endl;
}

2.3 菜单设计

2.3.1 主页面菜单设计

        主页面菜单（即一级菜单）使用switch-case语句实现。先定义一个choice_one变量，将输入的数值存入，通过判断choice_one来进入不同二级页面或退出。

int choice_one;
	choice_one = -1;
	while (choice_one != 0)
	{
		cout << "栈示例：" << endl;
		cout << "1. 顺序栈功能实现" << endl;
		cout << "2. 链栈功能实现" << endl;
		cout << "0. 退出" << endl;
		cout << "请选择:" << endl;
		cin >> choice_one;
		system("cls");

		switch (choice_one)
		{
		case 1:// 
			SeqStackMenu();
			system("pause");
			system("cls");
			break;

		case 2:// 
			LinkedStackMenu();
			system("pause");
			system("cls");
			break;

		case 0: // 0.退出
			cout << "欢迎下次使用！" << endl;
			system("pause");
			return 0;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;

		}
	}
2.3.2 二级页面菜单设计

       因为二级菜单内容较多，并未和一级菜单写在一个文件中，而是采取了分文件编写的思想，创建了my_menu.cpp和My_menu.h，将二级菜单存入其中。顺序栈和链栈的功能菜单分别写成函数，然后再直接在一级菜单中进行调用。为区分开，二级菜单定义了新的变量choice_two，用来存储二级菜单的选择数值。

// 顺序栈的功能菜单
void SeqStackMenu()
{
	SeqStack<int> Seq;
	/* 注意重置choice_two的值，否则将会再次进入会变为0，无法开始循环 */
	int choice_two = -1;

	while (choice_two)
	{
		cout << "顺序栈示例：" << endl;
		cout << "1. 创建指定长度的顺序栈" << endl;
		cout << "2. 将指定元素入栈" << endl;
		cout << "3. 弹出栈顶元素" << endl;
		cout << "4. 输出栈顶元素数值" << endl;
		cout << "5. 输出顺序栈的长度" << endl;
		cout << "6. 遍历打印顺序栈" << endl;
		cout << "0. 返回上一级菜单" << endl;
		cout << "请选择:" << endl;
		cin >> choice_two;

		switch (choice_two)
		{
		case 1:
			try
			{
				Seq.CreateSeqStack();
				cout << "顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 2:
			try
			{
				int value;
				cout << "请输入将要入栈的元素数值" << endl;
				cin >> value;
				Seq.Push(value);
				cout << "顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 3:
			try
			{
				int value = Seq.Pop();
				cout << "弹出的栈顶元素的数值为：" << value << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 4:
			try
			{
				cout << "当前顺序栈的栈顶元素数值为：" << Seq.GetTop() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 5:
			try
			{
				cout << "当前顺序栈的长度为：" << Seq.Length() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 6:
			try
			{
				cout << "当前顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 0:
			cout << "退出顺序栈功能菜单！" << endl;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;
		}
	}
}


// 链栈的功能菜单
void LinkedStackMenu()
{
	LinkedStack<int> Link;
	int choice_two = -1;

	while (choice_two)
	{
		cout << "链栈示例：" << endl;
		cout << "1. 创建指定长度的链栈" << endl;
		cout << "2. 将指定元素入栈" << endl;
		cout << "3. 弹出栈顶元素" << endl;
		cout << "4. 输出栈顶元素数值" << endl;
		cout << "5. 输出链栈的长度" << endl;
		cout << "6. 遍历打印链栈" << endl;
		cout << "0. 返回上一级菜单" << endl;
		cout << "请选择:" << endl;
		cin >> choice_two;

		switch(choice_two)
		{
		case 1:
			try
			{
				Link.CreateLinkedStack();
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 2:
			try
			{
				int value;
				cout << "请输入将入栈的元素数值：";
				cin >> value;
				Link.Push(value);
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 3:
			try
			{
				int value = Link.Pop();
				cout << "弹出的栈顶元素数值为：" << value << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 4:
			try
			{
				cout << "栈顶元素的数值为：" << Link.GetTop() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 5:
			try
			{
				int length = Link.Length();
				cout << "当前链表的长度为：" << length << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 6:
			try
			{
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 0:
			cout << "退出链栈功能菜单！" << endl;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;
		}
	}

}

3.全部代码(分文件编写)

SeqStack.h

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

#ifndef SeqStack_H
#define SeqStack_H


#define MAXSIZE 100 // 顺序栈最多可以存储多少个元素，可按要求更改

template<typename DataType>
class SeqStack
{
public:
	SeqStack();						// 构造函数，初始化一个空栈
	~SeqStack() {};					// 析构函数
	void CreateSeqStack();
	void Push(DataType x); 			// 入栈操作，将元素x入栈
	DataType Pop();					// 出栈操作，将栈顶元素弹出，并返回弹出的元素值
	DataType GetTop();				// 取出栈顶元素（并不删除）
	int Length();					// 求顺序栈长度
	int Empty();					// 判空操作
	void PrintStack();			// 遍历打印，按照出栈顺序打印

private:
	DataType data[MAXSIZE];
	int top;
};


#endif

SeqStack.cpp

#include "SeqStack.h"

//*****************************************************
//函数名：SeqStack
//函数功能：构造函数，初始化一个空栈
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
template<typename DataType>
SeqStack<DataType>::SeqStack()
{
	this->top = -1;
}

//*****************************************************
//函数名：CreateSeqStack
//函数功能：创建一个指定长度的顺序栈
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
template<typename DataType>
void SeqStack<DataType>::CreateSeqStack()
{
	int num, value;
	cout << "请输入要入栈的元素个数：";
	cin >> num;
	cout << "请输入要入栈的元素数值：";
	for (int i = 0; i < num; i++)
	{
		cin >> value;
		this->data[i] = value;
		this->top++;
	}
}

//*****************************************************
//函数名：Push
//函数功能：入栈操作，将元素x入栈
//输入参数：
//	DataType,x,即将入栈的元素数值
//输出参数：
//	无
//******************************************************
template<typename DataType>
void SeqStack<DataType>::Push(DataType x)
{
	if (this->top+1 == MAXSIZE) throw"上溢";
	this->data[top + 1] = x;
	this->top++;
}

//*****************************************************
//函数名：Pop
//函数功能：出栈操作，将栈顶元素弹出，并返回弹出的元素值
//输入参数：
//	无
//输出参数：
//	DataType,弹出元素的数值
//******************************************************
template<typename DataType>
DataType SeqStack<DataType>::Pop()
{
	DataType y;
	if (this->Empty() == 1) throw"下溢";
	y = this->data[top];
	this->top--;
	return y;
}

//*****************************************************
//函数名：GetTop
//函数功能：取出栈顶元素（并不删除）
//输入参数：
//	无
//输出参数：
//	DataType,栈顶元素的数值
//******************************************************
template<typename DataType>
DataType SeqStack<DataType>::GetTop()
{
	DataType y;
	if (this->Length() == 0) throw"下溢";
	// if (this->Empty == 1) throw"下溢";
	y = this->data[top];
	return y;

}

//*****************************************************
//函数名：Length
//函数功能：输出栈的长度
//输入参数：
//	无
//输出参数：
//	int,栈的长度
//******************************************************
template<typename DataType>
int SeqStack<DataType>::Length()
{
	return this->top+1;
}

//*****************************************************
//函数名：Empty
//函数功能：判断栈是否为空
//输入参数：
//	无
//输出参数：
//	1，代表栈为空；0，代表栈非空
//******************************************************
template<typename DataType>
int SeqStack<DataType>::Empty()
{
	if (this->top==-1)		
		return 1;
	else
		return 0;
}

//*****************************************************
//函数名：PrintStack
//函数功能：遍历打印栈
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
template<typename datatype>
void SeqStack<datatype>::PrintStack()
{
	int length = this->Length();

	if (length > 0)
	{
		for (int i = 0; i < length; i++)
			cout <<this->data[i] << " ";
		cout << endl;
	}
	else
		cout << "顺序栈为空" << endl;
}

LinkedStack.h

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

#ifndef LinkedStack_H
#define LinkedStack_H

template<typename DataType>
struct LinkNode {
	DataType data;//数据域
	LinkNode<DataType>* next;//指针域 
};

template<typename DataType>
class LinkedStack
{
public:
	LinkedStack() { top = NULL; }		// 构造函数，初始化一个空栈
	~LinkedStack();					// 析构函数
	void CreateLinkedStack();
	void Push(DataType x); 			    // 入栈操作，将元素x入栈
	DataType Pop();					    // 出栈操作，将栈顶元素弹出，并返回弹出的元素值
	DataType GetTop();				    // 取出栈顶元素（并不删除）
	int Length();					    // 求顺序栈长度
	int Empty();					    // 判空操作
	void PrintStack();		            // 遍历打印，按照出栈顺序打印

private:
	LinkNode<DataType>* top;
};


#endif

LinkedStack.cpp

#include "LinkedStack.h"

// 析构函数
template<typename DataType>
LinkedStack<DataType>::~LinkedStack()
{
	LinkNode<DataType>* p = top;
	while (this->top)
	{
		top = top->next;
		delete p;
		p = top;
	}
}

//*****************************************************
//函数名：CreateLinkedStack
//函数功能：创建一个指定长度的链栈
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
template<typename DataType>
void LinkedStack<DataType>::CreateLinkedStack()
{
	this->top = nullptr;
	LinkNode<DataType>* s = nullptr;

	int num, value;
	cout << "请输入要创建的链栈长度：";
	cin >> num;
	cout << "请输入入栈的元素数值：";

	for (int i = 0; i < num; i++) 
	{
		cin >> value;
		LinkNode<DataType>* newNode = new LinkNode<DataType>;
		newNode->data = value;
		newNode->next = top;
		top = newNode;
	}
}

//*****************************************************
//函数名：Push
//函数功能：入栈操作，将元素x入栈
//输入参数：
//	DataType,x,即将入栈的元素数值
//输出参数：
//	无
//******************************************************
template<typename DataType>
void LinkedStack<DataType>::Push(DataType x)
{
	// 申请一个数据域为x的结点s
	LinkNode<DataType>* s = new LinkNode<DataType>;
	if (!s)
	{
		cout << "分配内存失败";
		return;
	}
	s->data = x;
	s->next = top;
	top = s;
}

//*****************************************************
//函数名：Pop
//函数功能：出栈操作，将栈顶元素弹出，并返回弹出的元素值
//输入参数：
//	无
//输出参数：
//	DataType,弹出元素的数值
//******************************************************
template<typename DataType>
DataType LinkedStack<DataType>::Pop()
{
	if (this->Empty() == 1) throw"下溢";

	LinkNode<DataType>* temp = top;
	top = top->next;
	int y = temp->data;
	delete temp;
	return y;
}

//*****************************************************
//函数名：GetTop
//函数功能：取出栈顶元素（并不删除）
//输入参数：
//	无
//输出参数：
//	DataType,栈顶元素的数值
//******************************************************
template<typename DataType>
DataType LinkedStack<DataType>::GetTop()
{
	if (this->Empty() == 1) throw"下溢";

	return top->data;
}

//*****************************************************
//函数名：Empty
//函数功能：判断栈是否为空
//输入参数：
//	无
//输出参数：
//	1，代表栈为空；0，代表栈非空
//******************************************************
template<typename DataType>
int LinkedStack<DataType>::Empty()
{
	if (this->Length() == 0)
	{
		return 1;
	}
	else
		return 0;
}

//*****************************************************
//函数名：Length
//函数功能：输出栈的长度
//输入参数：
//	无
//输出参数：
//	int,栈的长度
//******************************************************
template<typename DataType>
int LinkedStack<DataType>::Length()
{
	int length = 0;
	LinkNode<DataType>* current = this->top;
	while (current != nullptr) {
		current = current->next;
		length++;
	}
	return length;
}

//*****************************************************
//函数名：PrintStack
//函数功能：遍历打印栈
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
template<typename DataType>
void LinkedStack<DataType>::PrintStack()
{
	LinkNode<DataType>* current = this->top;

	cout << "当前链表中的元素为：";
	while (current != nullptr) {
		cout << current->data << " ";
		current = current->next;
	}
	cout << endl;
}

my_Menu.h

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

#ifndef my_Menu_H
#define my_Menu_H

void SeqStackMenu();
void LinkedStackMenu();


#endif

my_Menu.cpp

#include "my_Menu.h"
#include "SeqStack.cpp"
#include "LinkedStack.cpp"


//*****************************************************
//函数名：SeqStackMenu
//函数功能：顺序栈的功能菜单
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
void SeqStackMenu()
{
	SeqStack<int> Seq;
	/* 注意重置choice_two的值，否则将会再次进入会变为0，无法开始循环 */
	int choice_two = -1;

	while (choice_two)
	{
		cout << "顺序栈示例：" << endl;
		cout << "1. 创建指定长度的顺序栈" << endl;
		cout << "2. 将指定元素入栈" << endl;
		cout << "3. 弹出栈顶元素" << endl;
		cout << "4. 输出栈顶元素数值" << endl;
		cout << "5. 输出顺序栈的长度" << endl;
		cout << "6. 遍历打印顺序栈" << endl;
		cout << "0. 返回上一级菜单" << endl;
		cout << "请选择:" << endl;
		cin >> choice_two;

		switch (choice_two)
		{
		case 1:
			try
			{
				Seq.CreateSeqStack();
				cout << "顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 2:
			try
			{
				int value;
				cout << "请输入将要入栈的元素数值" << endl;
				cin >> value;
				Seq.Push(value);
				cout << "顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 3:
			try
			{
				int value = Seq.Pop();
				cout << "弹出的栈顶元素的数值为：" << value << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 4:
			try
			{
				cout << "当前顺序栈的栈顶元素数值为：" << Seq.GetTop() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 5:
			try
			{
				cout << "当前顺序栈的长度为：" << Seq.Length() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 6:
			try
			{
				cout << "当前顺序栈的元素为:(从栈底开始遍历)" << endl;
				Seq.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 0:
			cout << "退出顺序栈功能菜单！" << endl;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;
		}
	}
}


//*****************************************************
//函数名：LinkedStackMenu
//函数功能：链栈的功能菜单
//输入参数：
//	无
//输出参数：
//	无
//******************************************************
void LinkedStackMenu()
{
	LinkedStack<int> Link;
	int choice_two = -1;

	while (choice_two)
	{
		cout << "链栈示例：" << endl;
		cout << "1. 创建指定长度的链栈" << endl;
		cout << "2. 将指定元素入栈" << endl;
		cout << "3. 弹出栈顶元素" << endl;
		cout << "4. 输出栈顶元素数值" << endl;
		cout << "5. 输出链栈的长度" << endl;
		cout << "6. 遍历打印链栈" << endl;
		cout << "0. 返回上一级菜单" << endl;
		cout << "请选择:" << endl;
		cin >> choice_two;

		switch(choice_two)
		{
		case 1:
			try
			{
				Link.CreateLinkedStack();
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 2:
			try
			{
				int value;
				cout << "请输入将入栈的元素数值：";
				cin >> value;
				Link.Push(value);
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 3:
			try
			{
				int value = Link.Pop();
				cout << "弹出的栈顶元素数值为：" << value << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 4:
			try
			{
				cout << "栈顶元素的数值为：" << Link.GetTop() << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 5:
			try
			{
				int length = Link.Length();
				cout << "当前链表的长度为：" << length << endl;
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 6:
			try
			{
				Link.PrintStack();
				system("pause");
				system("cls");
				break;
			}
			catch (const char* s)
			{
				cout << s << endl;
				system("pause");
				system("cls");
				break;
			}
		case 0:
			cout << "退出链栈功能菜单！" << endl;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;
		}
	}

}

main.cpp

#include<iostream>
#include "SeqStack.cpp"
#include "LinkedStack.cpp"
#include "my_Menu.h"
using namespace std;

int main()
{
	int choice_one;
	choice_one = -1;
	while (choice_one != 0)
	{
		cout << "栈示例：" << endl;
		cout << "1. 顺序栈功能实现" << endl;
		cout << "2. 链栈功能实现" << endl;
		cout << "0. 退出" << endl;
		cout << "请选择:" << endl;
		cin >> choice_one;
		system("cls");

		switch (choice_one)
		{
		case 1:// 
			SeqStackMenu();
			system("pause");
			system("cls");
			break;

		case 2:// 
			LinkedStackMenu();
			system("pause");
			system("cls");
			break;

		case 0: // 0.退出
			cout << "欢迎下次使用！" << endl;
			system("pause");
			return 0;
			break;

		default:
			cout << "非法输入，请重新选择！" << endl;
			system("pause");
			system("cls");
			break;

		}
	}

	system("plase");
	return 0;
}

初学数据结构与算法，若有不正确之处，敬请指正啦~

Treey_X
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构第三次上机 第三章之链栈
Haruno_Sakura的博客
11-04 2070
实验题2：实现链栈的各种基本运算的算法 内容： 编写一个程序listack.cpp,实现链栈的各种基本运算，并在此基础上设计一个程序exp3-2.cpp，完成如下功能： (1)初始化栈s。  (2)判断栈s是否非空  (3)依次进栈元素a,b,c,d,e;  (4)判断栈S是否非空。  (5)输出出栈序列   (6)判断栈S是否非空。 (7) 释放栈。 代码： #inc
编写一个程序，实现链栈的各种基本运算
热门推荐
Stay hungry
11-14 1万+
完成如下功能： （1）初始化链栈s； （2）判断链栈s是否非空； （3）依次进链栈元素a，b，c，d，e； （4）判断链栈s是否非空； （5）输出链栈长度； （6）输出从栈顶到栈底元素； （7）输出出链栈序列； （8）判断链栈s是否非空； （9）释放链栈； 代码： #include"iostream" #include"malloc.h" using na
数据结构实验2-栈和队列
Pengwill's Blog
03-03 4302
实现顺序栈的基本运算 实验要求 程序代码 运行结果 实现链栈基本运算 实验要求 程序代码 运行结果 实现循环队列的基本运算 实验要求 程序代码 运行结果 实现链队列的基本运算 实验要求 程序代码 运行结果 实现顺序栈的基本运算 实验要求 编写一个程序，实现顺序栈的各种基本运算，并在此基础上设计一个主程序完成如下功能： （1）初始化栈s； （2）判断栈s...
链栈及运算实现
Learn as if you were to live forever
01-26 1327
利用链式存储结构实现的栈称作链栈（link stack）.链栈中的每一个数据元素用一个结点表示，其数据形式与单链表完全相同。链栈从本质上讲就是单链表，无非是限制了插入和删除运算只能在链头进行，所有可以说链栈是限制插入和删除运算只能在链头进行的单链表。由于在链头运算，所以不用像单链表那样附加头结点，更方便运算。 链栈的类型定义如下： typedef struct node { ele
【数据结构】链栈的基本操作（C语言）
weixin_44358957的博客
03-04 5101
链栈的基本操作，无头结点，C语言，带注释
数据结构课程：顺序栈和链栈的实现
10-16
### 数据结构课程：顺序栈和链栈的实现 #### 栈的基本概念 栈是一种特殊的线性表，其特殊之处在于所有元素的插入和删除都只能在一端进行，这一端被称为栈顶(top)，与之相对的一端称为栈底(bottom)。栈通常支持以下...
停车场管理系统(C语言顺序栈+链栈+链队列)
04-20
本项目以C语言为基础，运用了顺序栈、临时栈链栈和排队车道链队列的数据结构，为实现停车场管理提供了高效而灵活的解决方案。 首先，让我们深入了解这些数据结构： 1. **顺序栈**：顺序栈是一种线性数据结构，它...
数据结构-栈的应用：顺序栈与链栈的应用
最新发布
03-22
在这个主题中，我们将专注于栈（Stack）这一特殊的数据结构，及其在实际应用中的两种主要实现方式：顺序栈（Sequential Stack）和链栈（Linked Stack）。栈通常被称为“后进先出”（LIFO，Last In First Out）的数据...
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
注：分为四个内容：顺序栈、链栈、循环队列、链队列。代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求...
C#实现顺序栈和链栈的代码实例
08-26
在本文中，我们将深入探讨如何使用C#编程语言实现顺序栈和链栈。栈是一种特殊的数据结构，遵循“后进先出”（LIFO）的原则，即最后压入的元素最先弹出。栈通常用于算法和操作系统的实现，如递归、表达式求值和内存...
顺序栈的基本操作和实现
Vagrant_pursue的博客
10-24 1528
文章目录前言1.栈的基本操作2.读入数据总结 前言 提示：以下是本篇文章正文内容，下面案例可供参考 1.栈的基本操作 代码如下（示例）： 2.读入数据 代码如下（示例）： data = pd.read_csv( 'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv') print(data.head()) 该处使用的url网络请求的数据。 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单.
【数据结构初阶】五、线性表中的栈（C语言 -- 顺序表实现栈）
正在努力学C呀！（要学好久呢......）
09-25 3602
线性表中的栈（顺序表实现栈）：1 . 栈（Stack）； 2 . 栈的实现 ； 3 . 对应代码
编写函数，创建一个顺序栈（数据自拟），编写函数，实现顺序栈的各种操作；
monkeier的博客
10-23 552
编写函数，创建一个顺序栈（数据自拟），编写函数，实现顺序栈的各种操作；
顺序栈/用数组实现栈
m0_58070522的博客
09-21 152
#include<iostream> #define MAXSIZE 100 using namespace std; typedef struct astack { int* top; int * base; int stacksize; }Astack; void stackinit(Astack &a1) { a1.base=new int [MAXSIZE]; a1.top=a1.base; a1.stacks...
栈：LinkStack（链栈）的全代码
2203_75582171的博客
10-17 148
【代码】栈：Link Stack（链栈）的全代码。
顺序栈的实现
weixin_48755527的博客
08-28 159
顺序栈 利用顺序存储创建的栈； 和顺序表相同，只是将顺序表添加了一些限制； 栈的特点：先入后出，后入先出； 在.h文件中搭建数据基本结构 #include<stdio.h> typedef int data_t; typedef struct{ data_t *data; //定义存储数据的指针 int maxlen; //定义能够存储数据的数量 int top; //指向栈顶 }sqstack,*linstack; /*一些功能函数*/ linstack creart(int len
【整理】数据结构——题目
夜的第七章
11-06 2459
文章目录前言一、预备知识a. 了解C++和Java基本语法结构，掌握递归思想。二、程序性能a. 了解复杂性表示和计算方法b. 掌握插入排序、选择排序、冒泡排序、名次排序的基本思想三、数据描述a. 掌握线性表的公式化描述、链表描述、间接寻址等存储方法b. 了解遍历器的作用和实现方法c. 掌握线性表的插入、删除、合并等运算方法d. 掌握箱子排序，计数排序 前言 已经到冲刺阶段了，整理尽量缩短时间。按100道非重复的题目来算，一天整理十道，最多需要30天整理完成，因为给专业课的时间现在还不是很多，废话不多说，开始
静态分配的顺序栈的结构实现（C语言）
qq_44812831的博客
07-05 70
【代码】静态分配的顺序栈的结构实现（C语言）
栈--C语言实现数据结构
2201_76062618的博客
07-14 4148
本文用详细介绍栈的性质以及用栈来解决问题，内容较为丰富
C++实现数据结构栈队列操作：顺序栈、链栈、循环队列、链队列
“此资源包含关于数据结构中栈和队列的C++实现，涉及顺序栈、链栈、循环队列和链队列的基本操作。文件包括代码和注释，提供了用栈进行进制转换和使用队列打印杨辉三角形的实际应用示例，并附有在Visual Studio（VS）...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值