栈的操作

1.获取栈的最小值

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。

思考过程

对于push和pop操作来说，都很简单，无论是数组实现栈，还是链表实现栈都很容易。但是唯独min函数不好做。

首先对于栈这个数据结构来说，我们只能获取第一个元素，也就是栈顶的元素。我们不能访问到别的元素，所以我们不行也不可能去遍历获取栈的最小值。

那么我们肯定需要去保存栈的最小值，但是每当一个元素出栈之后，这个最小值需要变动，那么怎么变动呢？这又是一个问题。

还有就是如何去保存这个最小值，如果我们维护一个优先队列，或者别的数据结构， 使得维护的结构是已经排序好的，那么当然可以，但是这对于空间和时间的开销来说都不行。

既然是栈，那么肯定有栈自己的解决方式。

只要维护另一个栈，就能完成这个任务。

最小栈

1、定义一个栈这里我们称为最小栈，原来的栈我们称为数据栈。

2、最小栈和数据栈元素个数一定相同。最小栈的栈顶元素为数据栈的所有元素的最小值。

3、数据栈入栈一个元素A，最小栈需要拿这个元素与最小栈栈顶元素B比较，如果A小于B，则最小栈入栈A。否则最小栈入栈B。

4、当数据栈出栈一个元素时，最小栈也同时出栈一个元素。

图形解释其过程

代码解释其过程

#include <iostream>
#include <stack>
#include <cstdlib>
#include <cstdio>

using namespace std;

stack<int> dataStack;
stack<int> minStack;

int main() 
{
    int n;
    while(cin>>n)
    {
        if(!minStack.empty() && minStack.top() <= n)
        {
            dataStack.push(n);
            minStack.push(minStack.top());
        }
        else
        {
            dataStack.push(n);
            minStack.push(n);
        }
        
        printf("当前栈的最小元素为：%d
",minStack.top());
    }
    return 0;
}

2.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

思路：push操作无所谓栈或队列，都是往里面加入元素。而区别在于pop操作，队列的pop操作取的是先push的元素，而栈pop的则是最后push的元素，怎样通过两个栈来实现队列的pop操作，是主要问题所在。举个例子，向stack1中逐个push进a,b,c，则stack1中元素{a,b,c}，c位于栈顶，再将stack1中元素pop，并push进stack2中，则stack2元素{c,b,a}，a位于栈顶，pop出的顺序为a,b,c，符合先进先出的队列。简而言之，stack2中的元素是符合队列pop顺序的，可以直接pop，而stack1中的元素要想按照队列的pop需先push到stack2中，即当stack2不为空时，可以直接pop，当stack2为空时，将stack1中的元素pop并push进stack2中，再pop。

说的有点乱，贴上代码，就会更容易理解：

import java.util.Stack;

public class Solution {
    public static Stack<Integer> stack1 = new Stack<Integer>();
    public static Stack<Integer> stack2 = new Stack<Integer>();

    public static void push(int node) {
        stack1.push(node);
    }

    public static int pop() {
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        if(stack2.empty()){
            System.out.println("queue is empty");
        }
        return stack2.pop();
    }
    public static void main(String[] args){
        push(1);
        push(2);
        push(3);
        push(4);
        System.out.println(pop());
    }
}

3.用两个队列实现一个栈

思路：栈的push操作，当两个队列都为空时，不妨将元素push进queue1；或者push进非空队列。栈的pop操作，根据队列的先进先出原则，先插入的元素在队首，后插入的在队尾，而栈的操作要求后进先出，即队尾的元素要先出，可以将非空队列的元素逐个出队并入队到空队列中，直到空队列剩余一个元素，此时删除这个元素即可。

贴出代码

package com.su.biancheng;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @title StackWithTwoQueues.java
 * @author Shuai
 * @date 2016-4-15下午9:00:25
 */
public class StackWithTwoQueues {
    public static Queue<Integer> queue1=new LinkedList<Integer>();
    public static Queue<Integer> queue2=new LinkedList<Integer>();
    public static void push(int e){
        //插入非空队列
        if(queue2.isEmpty())
　　　　　　　//offer添加
            queue1.offer(e);
        if(queue1.isEmpty())
            queue2.offer(e);
    }
    public static int pop(){
        //将非空队列的元素逐个出队并插入到空队列
        //poll,获取并移除此队列的头，如果此队列为空，则返回 null。
        //remove,获取并移除此队列的头。此方法与 poll 唯一的不同在于：此队列为空时将抛出一个异常。
        if(!queue1.isEmpty()){
            while(queue1.size()>1){
                queue2.offer(queue1.poll());
            }
            return queue1.poll();
        }
        else if(!queue2.isEmpty()){
            while(queue2.size()>1){
                queue1.offer(queue2.poll());
            }
            return queue2.poll();
        }
        return 0;

    }
    public static void main(String[] args){
        push(1);
        push(2);
        push(3);
        push(4);
        push(5);
        System.out.println(pop());
    }
}