用栈实现队列操作；递归逆序一个栈；栈的排序

算法1：
题目：编写一个类，用两个栈实现队列，支持队列的基本操作（add、poll、peek）
{代码}
/**
 * 编写一个类，用两个栈实现队列，支持队列的基本操作（add、poll、peek）
 * 两点必须做到：(1)如果stackPush要往stackPop中压入数据，必须一次性全部压完；
 *              (2)如果stackPop不为空，stackPush绝对不能像stackPop中压入数据
 */

import java.util.Stack;

public class TwoStacksQueue {
    public Stack<Integer> stackPush;//压入栈，只往这个栈压入数据
    public Stack<Integer> stackPop;//弹出栈，只从这个栈弹出数据
    public TwoStacksQueue(){
        stackPush = new Stack<>();
        stackPop = new Stack<>();
    }
    //将数据压入压入栈中
    public void add(int pushInt){
        stackPush.push(pushInt);
    }

    /**
     * 可以实现压入数据,返回先进入的元素并删除
     * @return stackPop.pop()
     */
    public int poll(){
        //当2个栈都为空时
        if(stackPop.empty() && stackPush.empty()){
            throw new RuntimeException("Queue is empty!");
        }else if(stackPop.empty()){//如果stackPop栈为空，stackPush不为空，将所有的stackPush中的数据全部压入stackPop
            while(!stackPush.empty()){
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.pop();
    }
    /**
     * 可以实现压入数据，只是返回了先进入的元素
     * @return stackPop.peek()
     */
    public int peek(){
        if(stackPop.empty() && stackPush.empty()){
            throw new RuntimeException("Queue is empty");
        }else if(stackPop.empty()){
            while(!stackPop.empty()){
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.peek();
    }

    //输入数据
    public void input(int[] ints){
        for (int i = 0; i < ints.length; i++) {
            add(ints[i]);
        }
        System.out.println("入队列的顺序："+stackPush);

    }

    public static void main(String[] args){
        TwoStacksQueue twoStacksQueue = new TwoStacksQueue();
        int[] ints = {4,5,7,2,5,2,9,0,8};
        twoStacksQueue.input(ints);
        for (int i:ints) {
            System.out.println(twoStacksQueue.poll()+"第"+i+"个出队列!");
        }
    }
}
//栈的特点先进后出；队列的特点是先进先出。

//empty() 是stack中的一个方法：测试堆栈是否为空。 当且仅当堆栈中不含任何项时返回 true；否则返回 false。
//isEmpty() 是stack继承于Vector<E>的一个方法：测试此向量是否不包含组件。当且仅当此向量没有组件（也就是说其大小为零）时返回 true；否则返回 false。
//如果变量未初始化或显式地设置为   Empty，则函数   IsEmpty   返回   True；否则函数返回   False。如果   expression   包含一个以上的变量，总返回   False。

算法2：
题目：仅用递归函数和栈操作逆序一个栈
{代码}

import java.util.Stack;

/**
 * 仅用递归函数和栈操作逆序一个栈
 */
public class ReverseStack {
    /**
     *将栈底元素返回并移除
     * @param stack
     * @return栈底元素，1,2,3
     */
    public int getAndRemoveLastElement(Stack<Integer> stack){
        int result = stack.pop();
        if(stack.isEmpty()){
            return result;
        }else{
            int last = getAndRemoveLastElement(stack);
            stack.push(result);
            return last;
        }
    }

    /**
     *将getAndRemoveLastElement得到的值，重新压入栈中
     * @param stack
     */
    public void reverse(Stack<Integer> stack){
        if(stack.isEmpty()){
            return;
        }
        int i = getAndRemoveLastElement(stack);
        reverse(stack);
        stack.push(i);
    }

    /**
     *将数据压入栈中
     * @param ints
     * @param stackData
     * @return stackData(数据栈)
     */
    public Stack<Integer> input(int[] ints,Stack<Integer> stackData){
        for (int i=0;i<ints.length;i++) {
           stackData.push(ints[i]);
        }
        return stackData;
    }

    public static void main(String[] args){
        Stack<Integer> stackData = new Stack<>();
        ReverseStack reverseStack = new ReverseStack();
        int[] ints = {3,2,1};
        stackData =  reverseStack.input(ints,stackData);
        System.out.println("逆序之前："+stackData);
        reverseStack.reverse(stackData);
        System.out.println("逆序之后："+stackData);
    }
}

算法3:
题目：用一个栈实现另一个栈的排序
{代码}

import java.util.Stack;

/**
 * 用一个栈实现另一个栈的排序
 */
public class SortStack {
    /**
     *
     * @param stack 需要排序的栈
     */
    public static void sortStackByStack(Stack<Integer> stack){
        Stack<Integer> help = new Stack<>();
        while (!stack.isEmpty()){
            int cur = stack.pop();//得到栈顶值并删除该栈顶值
            while (!help.isEmpty() && help.peek() > cur){
                stack.push(help.pop());
            }
            help.push(cur);
        }
        while (!help.isEmpty()){
            stack.push(help.pop());
        }
    }

    public static Stack<Integer> input(int[] ints,Stack<Integer> stack){
        for (int i = 0;i<ints.length;i++) {
            stack.push(ints[i]);
        }
        return stack;
    }
    public static void main(String[] args){
        int[] ints = {1,2,3,4,5,6,7,8,9};
        Stack<Integer> stackData = new Stack<>();
        stackData = input(ints,stackData);
        System.out.println("原数据栈："+stackData);
        sortStackByStack(stackData);
        System.out.println("排序后："+stackData);
    }
}