栈和队列及模拟实现

1、栈

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照后进先出的原则存储数据。

先进入的数据被压入栈底，最后的数据在栈顶；需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

结构比较简单，基本操作如下：

#pragma once
#include<iostream>
using namespace std;
template<class T>
class Stack
{
public:
	Stack()             //构造函数
		:_d(NULL)
		, _size(0)
		, _capacity(0)
	{} 
	~Stack()             //析构函数
	{
		if (_d)
		{
			delete _d;
			_d = NULL;
		}
	}
public:
	void Push(T d)       //压栈
	{
		CheckCapacity();
		_d[_size] = d;
		_size++;
	}
	void Pop()          //出栈
	{
		if (Top() != NULL)  //如果栈不为空
		{
			_size--;
		}
	}
	T& Top()            //栈顶元素
	{
		return _d[_size - 1];
	}
	size_t Size()       //返回栈大小
	{
		return _size;
	}  
	bool Empty()       //判断是否为空
	{
		return Top() == NULL;
	}

	void Display()
	{
		for (size_t i = 0; i < _size; i++)
		{
			cout << _d[i] << " ";
		}
		cout << endl;
	}
private:
	void CheckCapacity()   //检查容量
	{
		if (_size == _capacity)
		{
			size_t NewCapacity = _capacity * 2 + 3;
			T *tmp = new T[NewCapacity];
			for (size_t i = 0; i < _size; i++)
			{
				tmp[i] = _d[i];
			}
			delete[] _d;
			_d = tmp;
			_capacity = NewCapacity;
		}
	}
protected:
	T *_d;
	size_t _size;
	size_t _capacity;
};

void test()
{
	Stack<int> s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	s1.Display();

	s1.Pop();
	s1.Display();

	cout << s1.Empty() << endl;
	cout << s1.Size() << endl;
	cout << s1.Top() << endl;
}

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

看运行结果：

这里，1是栈底，第一个入栈，4是栈顶，弹出时从栈顶开始弹出数据（最后一个数据被第一个读出来），因此第二次打印为1，2，3

因此有三个元素，栈顶元素为3.

2.队列

队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。

队首(front) ：允许进行删除的一端称为队首。
队尾(rear) ：允许进行插入的一端称为队尾。
例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开队列。

基本操作实现如下：

template<class T>
class LinkQueue           //队列节点
{
public:
	LinkQueue()
		:_d(NULL)
		,next(NULL)
	{}
	LinkQueue(T& d)
		:_d(d)
		,next(NULL)
	{}
	~LinkQueue()
	{}
public:
	T _d;
	LinkQueue *next;
};
template<class T>
class Queue
{
public:
	Queue()
		:_front(NULL)
		, _rear(NULL)
	{}
	void Push(T d)            //尾插
	{
		if (_front == NULL)
		{
			_front = new LinkQueue<T>;    //头结点
			_front->next= new LinkQueue<T>(d);  //插入d
			_rear = _front->next;
		}
		else
		{
			_rear->next= new LinkQueue<int>(d);
			_rear = _rear->next;
		}
	}
	void Pop()                   //头删
	{
		assert(_front&&_rear);
		if (_front == _rear)  //队列为空
		{
			return;
		}
		else
		{
			LinkQueue<int> *tmp = _front->next;
			_front->next = tmp->next;
			delete tmp;
			tmp = NULL;
		}
	}
	size_t Size()                   //队列节点个数
	{
		assert(this);
		size_t size = 0;
		LinkQueue<int> *tmp = _front->next;
		while (tmp != NULL)
		{
			size++;
			tmp = tmp->next;
		}
		return size;
	}
	bool Empty()              //队列是否为空
	{
		return _front == _rear;
	}
	T Top()                //队头元素
	{
		if (!Empty())
		{
			LinkQueue<int> *tmp = _front->next;
			return tmp->_d;
		}
		return 0;
	}
	~Queue()
	{
		LinkQueue<int> *tmp = _front->next;
		while (tmp != NULL)
		{
			delete _front;
			_front = tmp;
			tmp = tmp->next;
		}
	}

	void display()
	{
		LinkQueue<int> *tmp = _front->next;
		while (tmp != NULL)
		{
			cout << tmp->_d << " ";
			tmp = tmp->next;
		}
		cout << endl;
	}
private:
	LinkQueue<T> *_front;
	LinkQueue<T> *_rear;
};

void test()
{
	Queue<int> q1;
	q1.Push(1);
	q1.Push(2);
	q1.Push(3);
	q1.Push(4);
	q1.display();

	q1.Pop();
	q1.display();

	cout << q1.Empty() << endl;
	cout << q1.Size() << endl;
	cout << q1.Top() << endl;

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

分析运行结果：

队首为先入队的元素，因此Pop后剩2，3，4，元素个数为3，队首为2。