实现特殊的栈和队列

利用一个固定数组实现栈和队列

class ArrayStack //用数组实现栈
{
public:
	ArrayStack(int initsize) //创建一个固定长度的数组
	{
		if (initsize < 0)
		{
			cout << "数组长度小于0" << endl;
		}
		else
		{
			array = vector<int>(initsize - 1);
			size = 0;
		}
	}

	void push(int obj)
	{
		if (size == array.size())
			cout << "栈已满" << endl;
		else
			array[size++] = obj;
	}

	int pop()
	{
		if (size == 0)
			cout << "栈为空" << endl;
		else
			return array[--size];

	}

	int top()
	{
		if (size == 0)
			return NULL;
		else
			return array[size - 1];
	}

private:
	vector<int> array;
	int size;
};

class ArrayQueue //用数组实现队列
{
public:
	ArrayQueue(int initsize)
	{
		if (initsize < 0)
			cout << "数组长度小于0" << endl;
		else
		{
			vector<int> array(initsize-1);
			size = 0;
			start = 0;
			end = 0;
		}
	}
   
	void push(int obj)
	{
		if (size == array.size())
			cout << "队列已满" << endl;
		else
		{
			array[end++] = obj;
			size++;
			if (end == array.size()) //当队尾到达数组的最后一个位置时，队尾指针转而指向数组的第一个位置
				end = 0;
		}
	}

	int pop()
	{
		if (size == 0)
			cout << "队列为空" << endl;
		else
		{
			size--;
			int tmp = start;
			if (start == array.size() - 1) //当队首到达数组的最后一个元素时，经过pop操作，指向数组的第一个元素
				start = 0;
			else
				start++;
			return array[tmp];
		}
	}
    
    int top()
    {
        if(size == 0)
            return NULL;
        else
            return array[start];
    }

private:
	vector<int> array;
	int size;
	int start; //指向队首
	int end;  //指向队尾元素的后一个位置，该位置为空
};

具有返回min功能的栈

使用两个栈，一个为data栈，一个为min栈。在进行push操作时，首先向data栈中push值，如果push的值小于min栈的栈顶，则向min栈中push这个值，如果大于等于min栈的栈顶，则再push一个min栈栈顶的值。在进行pop操作时，data栈和min栈都对栈顶进行pop。进行top操作，即对data栈取top，进行min操作，即对min栈取top。

class MinStack
{
public:
	void push(int value) 
	{
		stackdata.push(value);
		if (stackmin.empty() || value<stackmin.top()) //压入元素小于min栈顶，则压入该元素；否则再压入一个栈顶元素。
			stackmin.push(value);
		else stackmin.push(stackmin.top());
	}
    
	void pop() 
	{
		if (!stackmin.empty())
		{
			stackmin.pop();
			stackdata.pop();
		}
        else
            cout << "栈为空" << endl;
	}
    
	int top() 
	{
		return stackdata.top();
	}

	int min() 
	{
		return stackmin.top();
	}

private:
	stack<int> stackmin;
	stack<int> stackdata;
};

用两个队列实现栈

使用两个队列，一个为data队列，另一个为help队列。在进行push操作时，向data队列中push值。在进行pop操作时，不断地将data队列的首元素弹出并且压入help队列中，直到data队列中只剩下一个元素，将该元素pop，交换data队列和help队列。在进行top操作时，与pop操作不同的是，不仅要返回data队列中的最后一个元素，还要将这个元素压入help栈中。最后交换data队列和help队列。

class QueueStack
{
public:
	void push(int obj)
	{
		queuedata.push(obj);
	}

	void pop()
	{
		if (queuedata.empty())
			cout << "栈为空" << endl;
		else
		{
			while (queuedata.size() > 1)
			{
				queuehelp.push(queuedata.front());
				queuedata.pop();
			}
			queuedata.pop();
			queue<int> tmp = queuehelp;
			queuehelp = queuedata;
			queuedata = tmp;
		}	
	}

	int top()
	{
		if (queuedata.empty())
			return NULL;
		else
		{
			while (queuedata.size() > 1)
			{
				queuehelp.push(queuedata.front());
				queuedata.pop();
			}
			int res = queuedata.front();
			queuedata.pop();
			queuehelp.push(res);
			queue<int> tmp = queuehelp;
			queuehelp = queuedata;
			queuedata = tmp;
			return res;
		}
	}

private:
	queue<int> queuedata;
	queue<int> queuehelp;
};

用两个栈实现队列

使用两个栈，一个为push栈，另一个为pop栈。在进行push操作时，向push栈中push值。在进行pop操作时，如果pop栈不为空，直接在pop栈执行pop操作；在pop栈为空时，则将push栈中的栈顶元素依次弹出并且压入pop栈中，再对pop栈执行pop操作。top操作与pop类似。

class StackQueue
{
public:
	void push(int obj)
	{
		stackpush.push(obj);

	}

	void pop()
	{
		if (stackpop.empty() && stackpush.empty())
			cout << "队列为空" << endl;
		else if (stackpop.empty())
		{
			while (!stackpush.empty())
			{
				stackpop.push(stackpush.top());
				stackpush.pop();
			}
		}
		stackpop.pop();
	}

	int top()
	{
		if (stackpop.empty() && stackpush.empty())
			return NULL;
		else if (stackpop.empty())
		{
			while (!stackpush.empty())
			{
				stackpop.push(stackpush.top());
				stackpush.pop();
			}
		}
		stackpop.top();
	}

private:
	stack<int> stackpush;
	stack<int> stackpop;
};