队列与栈的一些基本问题

实现栈

#pragma once
#include<assert.h>
template<class T>
class stack
{
public:
	stack()
		:_size(0)
		, _capacity(0)
		, _arr(NULL)
	{}
	~stack()
	{
		if (_size != 0)
		{
			delete[] _arr;
			_arr = NULL;
		}
			_size = 0;
			_capacity = 0;
		
	}

	stack(const stack& s)
		:_capacity(new T(s._capacity-1))
	{
		swap(_arr, s._arr);
		_size = s._size;
		_capacity = s._capacity;
	}
	void CheckCapacity()
	{
		
		if (_capacity==_size)
		{
			size_t Newcapacity = _capacity * 2 + 3;
			T* tmp = new T[Newcapacity];
			assert(tmp);
			size_t i = 0;
			while (i<_size)
			{
				tmp[i] = _arr[i];
				i++;
			}
			delete[] _arr;
			_arr = tmp;
			_capacity = Newcapacity;
		}
	}
	void Push(const T& x)
	{
		if (_size == _capacity)
		{
			CheckCapacity();
		}
	
		_arr[_size] = x;
		_size++;
	
	}

	T& Min()
	{
		return Top();
	}
	void Pop()
	{
		if (_size > 0)
		{
			_size--;
		}
	}
	T& Top()
	{
		return _arr[_size-1];
	}
	bool Empty()
	{
		return _size == 0;
	}

	size_t Size()
	{
		return _size;
	}
	void Dispaly()
	{
		if (_size == 0)
		{
			cout << "STACK NULL"<<endl;
		}
		else
		{
			size_t i = 0;
			while (i < _size)
			{
				cout << _arr[i]<<" ";
				i++;
			}
			cout << endl;
		}
	}

protected:
	size_t _size;
	size_t _capacity;
	T* _arr;
};

实现队列

#pragma once

#include<assert.h>
template<class T>

struct QueueNode
{
	int _data;
	QueueNode<T>* _next;
};
template<class T>

class queue
{
public:
	typedef QueueNode<T> Node;
	queue()
		:_head(NULL)
		, _tail(NULL)
	{}
	void  Push(const T& x)
	{
		if (NULL == _head)
		{
			_head = new Node;
			_head->_data = x;
			_head->_next = NULL;
			_tail = _head;
		}
		else
		{
			Node* tmp = new Node;
			tmp->_data = x;
			tmp->_next = NULL;
			_tail->_next = tmp;
			_tail = _tail->_next;
		}
	}
	void Pop()
	{
		assert(_head);
		Node* cur = _head;
		_head = _head->_next;
		delete cur;
		cur = NULL;
	}

	size_t Size()
	{
		size_t count = 0;
		if (_head == _tail)
		{
			if (_head == NULL)
			{
				return 0;
			}
			return 1;
		}
		else
		{
			Node* cur = _head;
				while (cur)
				{
					++count;
					cur = cur->_next;
				}
			return count;
		}
	}

	T& Front()
	{
		return _head->_data;
	}
	T& Back()
	{
		return _tail->_data;
	}
	bool Empty()
	{
		if (_head == NULL)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

protected:
	Node* _head;
	Node* _tail;
};

#include"stack.h"
#include"queue.h"
#include<iostream>
using namespace std;
#include<assert.h>

//检查合法出栈入栈

//bool CheckLegal(int* stack_in,int* stack_out,size_t len_in,size_t len_out)
//{
//	assert(stack_in&&stack_out);
//	if (len_in != len_out)
//	{
//		return false;
//	}
//	int i = 0;
//	int j = 0;
//	stack<int> s;
//	queue<int> q;
//	for (i = 0; i < len_in; i++)
//	{
//		s.Push(stack_in[i]);
//	}
//	int x = 2;
//	while (x--)
//	{
//		q.Push(s.Top());
//		s.Pop();
//	}
//	int a = 2;
//	while (a--)
//	{
//		s.Push(q.Front());
//		q.Pop();
//	}
//	while(s.Size() > 0 && s.Top() == stack_out[j])
//	{
//	
//			s.Pop();
//			j++;
//		
//	}
//	return (s.Size() > 0) ? false:true;
//}
//两个队列实现一个栈
//template<class T>
//class stack
//{
//
//public:
//	void Push(const T& x)
//	{
//		q1.Push(x);
//	}
//	void Pop()
//	{
//		if (q1.Size() == 0)
//		{
//			cout << "STACK  NULL" << endl;
//		}
//		else if(q1.Size()==1)
//		{
//			q1.Pop();
//		}
//		else
//		{ 
//			while (q1.Size()>1)
//			{
//				q2.Push(q1.Front());
//				q1.Pop();
//				
//			}
//			q1.Pop();
//			while (!q2.Empty())
//			{
//				q1.Push(q2.Front());
//				q2.Pop();
//
//			}
//		}
//		
//	}
//	T& Top()
//	{
//		return q1.Back();
//	}
//	size_t Size()
//	{
//		return q1.Size();
//	}
//protected:
//	queue<T> q1;
//	queue<T> q2;
//
//
//};

//两个栈实现一个队列
//
//
//template<class T>
//class queue
//{
//	T top = 0;
//public:
//	void Push(const T& x)
//	{
//		s1.Push(x);
//		top = s1.Top();
//	}
//	void Pop()
//	{
//		while (!s1.Empty())
//		{
//			s2.Push(s1.Top());
//			s1.Pop();
//		}
//		s2.Pop();
//	}
//	T& Front()
//	{
//		while (!s1.Empty())
//		{
//			
//			s2.Push(s1.Top());
//			s1.Pop();
//		}
//		return s2.Top();
//	}
//	T& Back()
//	{
//		return top;
//	}
//	size_t Size()
//	{
//		return s2.Size();
//	}
//protected:
//	stack<T> s1;
//	stack<T> s2;
//
//};



//O(1) 时间复杂度 的 Min函数
//template<class T>
//class Minstack
//{
//public:
//	void Push(const T& x)
//	{
//		s.Push(x);
//		if (smin.Empty() || x <= smin.Top())
//		{
//			smin.Push(x);
//		}
//	}
//	void Pop()
//	{
//		if (s.Top() = smin.Top())
//		{
//			s.Pop();
//			smin.Pop();
//		}
//
//	}
//	T& Min()
//	{
//		return smin.Top();
//
//	}
//
//
//protected:
//	stack<T> s;
//	stack<T> smin;
//};

//int main()
//{
//	int stack_in[] = { 1,2,3,4,5 };
//	int stack_out[] = { 4,5,3,2,1 };
//	int len_in = sizeof(stack_in) / sizeof(stack_in[0]);
//	int len_out = sizeof(stack_out) / sizeof(stack_out[0]);
//	bool ret = CheckLegal(stack_in, stack_out, len_in, len_out);
//	if (ret)
//		cout << "出栈顺序合法" << endl;
//	else
//		cout << "出栈顺序不合法" << endl;
//	queue<int> q;
//	q.Push(1);
//	q.Push(2);
//	q.Push(3);
//	q.Push(4);
//	q.Pop();
//	q.Push(6);
//	q.Push(7);
//	q.Push(8);
//	q.Pop();
//	cout << q.Front() << endl;
//	cout << q.Back() << endl;
//	cout << q.Size()<< endl;
//

	//Minstack<int> s;
	//s.Push(2);
	//s.Push(2);
	//s.Push(3);
	//s.Push(4);
	//s.Push(1);
	//s.Pop();
	//cout<<s.Min()<<endl;


	/*stack<int> s;
	
	s.Pop();
	s.Push(1);
	s.Pop();
	cout << s.Top() << endl;
	s.Push(2);
	cout << s.Size() << endl;
	s.Pop();
	cout << s.Top() << endl;

	s.Push(3);
	s.Push(4);
	cout << s.Top() << endl;

	s.Pop();
	cout << s.Top() << endl;
*/
	//s.Dispaly();
	//cout << s.Min()<<endl;
	return 0;
}