温故而知新 -＞ 数据结构 -＞利用 栈 实现 队列 -＞ 程序实现2_利用类

温故而知新 -＞ 数据结构 -＞利用 栈 实现 队列 -> 程序实现2_利用类

本篇博客是基于 温故而知新 -＞ 数据结构 -＞ 线性表 -＞队列 && 栈 中利用 栈 实现 队列 的理论知识进行程序实现！

其中结合了 温故而知新-＞数据结构-＞栈-＞程序实现2_利用类 中的代码，实现了队列的 增（入队）删（出队）查（队头与队尾元素）改（没写(～￣▽￣)～），判空，打印等操作！并附带了实例以及对应的运行结果！

注意：其中代码多多少少有点冗余，且未考虑性能最优，读者有兴趣可进一步精简！

具体内容如下
（1）SQueue.h

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>


typedef int STDataType;
class stack
{
public:
	stack() :_val(nullptr)
		, _size(0)
		, _capa(0)
	{}

	~stack()
	{
		if (_val != nullptr)
		{
			free(_val);
			_val = NULL;
			_size = _capa = 0;
		}
	}

	// 检查栈容量
	void checkCapacity();
	// 插入 - 入栈 （相当于是尾插）
	void stackPush(STDataType val);
	// 删除 - 出栈 （相当于是尾删）
	void stackPop();

	// 元素个数
	int stackSize();
	// 判空
	bool stackEmpty();

	// 获取栈顶元素 -- 直接返回数据即可
	STDataType stackTop();
	// 栈内元素打印
	void stackPrint();
private:
	STDataType *_val;
	int _size;
	int _capa;
};

class SQueue:public stack
{
public:
	SQueue()
	{
		enSta = new stack();
		deSta = new stack();
	}
	~SQueue()
	{
		delete(enSta);
		delete(deSta);
	}

	// 队尾入队列
	void SQueuePush(STDataType data);
	// 队头出队列
	void SQueuePop();
	// 打印队列
	void SQueuePrint();
	// 获取队列头部元素
	STDataType SQueueFront();
	// 获取队列队尾元素
	STDataType SQueueRear();
	// 获取队列中有效元素个数
	int SQueueSize();
	// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
	bool SQueueEmpty();

private:
	stack *enSta;//入队栈
	stack *deSta;//出队栈
};

（2）main.cpp

/* 利用栈实现队列 */
#include"SQueue.h"

/* 先是对stack中函数的定义 */
// 检查栈容量
void stack::checkCapacity()
{
	if (_size == _capa)
	{
		int newCapa = _capa == 0 ? 1 : 2 * _capa;
		_val = (STDataType*)realloc(_val, newCapa*sizeof(STDataType));
		_capa = newCapa;
	}
}
// 插入 - 入栈 （相当于是尾插）
void stack::stackPush(STDataType val)
{
	//assert(_val != NULL);
	stack::checkCapacity();
	_val[_size] = val;
	_size++;
}
// 删除 - 出栈 （相当于是尾删）
void stack::stackPop()
{
	assert(_val != NULL || _size == 0);
	_size--;
}

// 元素个数
int stack::stackSize()
{
	return _size;
}
// 判空
bool stack::stackEmpty()
{
	if (_val == NULL || _size == 0)
	{
		//cout << "空栈" << endl;
		return true;
	}
	else
	{
		//cout << "非空栈" << endl;
		return false;
	}
}

// 获取栈顶元素 -- 直接返回数据即可
STDataType stack::stackTop()
{
	return _val[_size - 1];
}
// 栈内元素打印，遵循先进后出原则
void stack::stackPrint()
{
	assert(_val != NULL);
	int i = _size - 1;
	//cout << "栈内元素：";
	while (i >= 0)
	{
		cout << _val[i--] << " ";
	}cout << endl;
}

/* 对SQueue类中函数进行定义*/
// 队尾入队列
void SQueue::SQueuePush(STDataType data)
{
	enSta->stackPush(data);
}
// 队头出队列
void SQueue::SQueuePop()
{
	if (deSta != NULL)
		deSta->stackPop();
	else
	{
		//将入队栈的所有数据存入出队栈
		while (enSta != NULL)
		{
			deSta->stackPush(enSta->stackTop());
			enSta->stackPop();
		}
		//删除出队栈的栈顶即完成了队列的出队操作
		deSta->stackPop();
	}
}
// 打印队列
void SQueue::SQueuePrint()
{
	if (enSta->stackEmpty() && deSta->stackEmpty())//判断入队栈与出队栈是否都为空
		return;
	//此时三种情况：
	//	1、入队栈有数据，出队栈为空 -- 打印时候，先输入的应该在前，代表队头
	//	2、入队栈为空，出队栈有数据 -- 打印时候，正常打印，因为出队栈的栈顶代表了队头
	//	3、两个栈都有数据 -- 先打印出队栈，再逆向打印入队栈
	cout << "队列元素：";
	if (!enSta->stackEmpty() && deSta->stackEmpty())
	{
		//一个简单办法，将入队栈数据存入出队栈，然后打印出队栈数据即可
		while (!enSta->stackEmpty())
		{
			deSta->stackPush(enSta->stackTop());
			enSta->stackPop();
		}
		deSta->stackPrint();
	}
	else if (enSta->stackEmpty() && !deSta->stackEmpty())
	{
		deSta->stackPrint();
	}
	else 
	{
		//此时实现办法较多，比如用一个中间变量，保存入队栈的数据，然后打印完，再存入入队栈
		deSta->stackPrint();
		stack *tmp = new stack();
		while (!enSta->stackEmpty())
		{
			tmp->stackPush(enSta->stackTop());
			enSta->stackPop();
		}
		tmp->stackPrint();
		while (!tmp->stackEmpty())
		{
			enSta->stackPush(tmp->stackTop());
			tmp->stackPop();
		}
		delete(tmp);//用new创建的对象指针，需要用delete进行释放
	}
}
// 获取队列头部元素
STDataType SQueue::SQueueFront()
{
	if (enSta->stackEmpty() && deSta->stackEmpty())//判断入队栈与出队栈是否都为空
		return NULL;
	if (!enSta->stackEmpty() && deSta->stackEmpty())
	{
		//一个简单办法，将入队栈数据存入出队栈，然后打印出队栈数据即可
		while (!enSta->stackEmpty())
		{
			deSta->stackPush(enSta->stackTop());
			enSta->stackPop();
		}
	}
	return deSta->stackTop();
}
// 获取队列队尾元素
STDataType SQueue::SQueueRear()
{
	if (enSta->stackEmpty() && deSta->stackEmpty())//判断入队栈与出队栈是否都为空
		return NULL;
	if (!enSta->stackEmpty())
	{
		return deSta->stackTop();
	}
	else
	{
		//此时入队栈为空，出队栈有数据，所以此时的队尾元素相当于出队栈的栈底元素，为获得栈底元素，
		//先将出队栈中的数据存入入队栈，获得栈底元素后，再把入队栈中的数据存至出队栈
		while (!deSta->stackEmpty())
		{
			enSta->stackPush(deSta->stackTop());
			deSta->stackPop();
		}
		STDataType tmp = enSta->stackTop();
		while (!enSta->stackEmpty())
		{
			deSta->stackPush(enSta->stackTop());
			enSta->stackPop();
		}
		return tmp;
	}
	
}
// 获取队列中有效元素个数
int SQueue::SQueueSize()
{
	return enSta->stackSize() + deSta->stackSize();
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool SQueue::SQueueEmpty()
{
	return enSta->stackEmpty() && deSta->stackEmpty();
}

void test()
{
	SQueue sq;
	/* 实验入队操作 */
	sq.SQueuePush(1);
	sq.SQueuePush(2);
	sq.SQueuePush(3);
	sq.SQueuePush(4);
	sq.SQueuePrint();// 1 2 3 4
	cout << endl;

	/* 实验出队操作 */
	sq.SQueuePop();
	sq.SQueuePrint();// 2 3 4
	sq.SQueuePop();
	sq.SQueuePrint();// 3 4
	//sq.SQueuePop();
	//sq.SQueuePrint();// 4
	//sq.SQueuePop();
	//sq.SQueuePrint();//会没有值打印，因为此时队内元素为空
	cout << endl;

	/* 实验队头元素 */
	cout << "此时队头元素为：" << sq.SQueueFront() << endl;
	/* 实验队尾元素 */
	cout << "此时队尾元素为：" << sq.SQueueRear() << endl;
	cout << endl;

	/* 实验元素个数 */
	cout << "此时有效元素个数：" << sq.SQueueSize() << endl;
	cout << endl;

	/* 实验是否为空 */
	cout << "此时队列状态（0：非空，1：空）：" << sq.SQueueEmpty() << endl;
}

int main()
{
	test();
	system("pause");
	return 0;
}

（3）运行结果

以上为本篇博客内容，若有问题，欢迎与笔者交流！
侵权删~