算法与数据结构——一些特殊的栈总结【有序的栈、能返回栈中最小元素的栈、队列与栈的相互转化问题】（Java）-CSDN博客

本文链接：https://blog.csdn.net/Borslav/article/details/125843217

有序的栈

类似单调栈的结构

辅助栈要求规则是从栈底到栈顶是从大到小的

每次从栈中弹出一个数尝试加入到辅助栈中，如果符合规则就直接加入，不符合规则就一直弹出辅助栈压回到主栈中直到该数字能加入到辅助栈中

当主栈空的时候辅助栈就是有序的

再把辅助栈的数一次性全部倒入回主栈，此时主栈就是有序的

public void sortStack(Stack<Integer> stack){
    Stack<Integer> help=new Stack<>();
    while(!stack.isEmpty()){
        int pre=stack.pop();
        while(!help.isEmpty()&&help.peek()<pre){
            stack.push(help.pop());
        }
        help.push(pre);
    }
    while(!help.isEmpty()){
        stack.push(help.pop());
    }
}

特殊的栈

准备两个栈

一个是普通的栈

另外一个栈：进元素时看当前元素和栈顶元素，谁小压谁

这样就做到了每弹出一个元素时知道当前栈中的最小值是谁

public class Mystack{
    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;
    
    public Mystack(){
        dataStack=new Stack<>();
        minStack=new Stack<>();
    }
    
    public void push(int newNum){
        if(this.minStack.empty()){
            this.minStack.push(newNum);
        }else if(newNum<minStack.peek()){
            this.minStack.push(newNum);
        }else{
            int newMin=this.minStack.peek();
            this.minStack.push(newMin);
        }
        this.dataStack.push(newNum);
    }
    
    public int pop(){
        if(this.dataStack.empty()){
            throw new RuntimeException("Your stack is Empty");
        }
        this.minStack.pop();
        return this.dataStack.pop();
    }
    
    public int getMin(){
        if(this.minStack.empty()){
            throw new RuntimeException("Your stack is Empty");
        }
        return this.minStack.peek();
    }
}

结构转化

如何仅用队列结构实现栈结构

准备两个队列

进来的元素全部加到队列一中

当需要弹出的时候把队列一的除末尾的数全部加入到队列二中把末尾的数弹出返回即可再把两个队列的数据状况做交换即可

public class queueToStack{
    private Queue<Integer> queue;
    private Queue<Integer> help;

    public TwoQueuesStack() {
        queue = new LinkedList<Integer>();
        help = new LinkedList<Integer>();
    }
    
    public void push(int num){
        queue.add(num);
    }
    
    public int peek(){
        if(queue.isEmpty()){
            throw new RuntimeException("Stack is Empty");
        }
        while(queue.size()!=1){
            help.add(queue.pop());
        }
        int res=queue.poll();
        help.add(res);
        swap();
        return res;
    }
    
    public void swap(){
        Queue<Integer> tmp=help;
        help=queue;
        queue=tmp;
    }
    
    public int pop(){
        if(queue.isEmpty()){
            throw new RuntimeException("Stack is Empty");
        }
        while(queue.size()!=1){
            help.add(queue.pop());
        }
        int res=queue.poll();
        swap();
        return res;
    }
}

如何仅用栈结构实现队列结构

准备两个栈

先把全部元素加入到push栈中

全部导入pop栈中

pop栈弹出的结果就是队列要求的顺序

public class StackToQueue{
    private Stack<Integer> pushStack;
    private Stack<Integer> popStack;
    
    public StackToQueue(){
        pushStack=new Stack<>();
        popStack=new Stack<>();
    }
    
    public void push(int num){
        pushSatck.push(num);
        convert();//做任何操作时都看一下能不能倒
    }
    
    public int poll(){
        if(popStack.empty()&&pushStack.empty()){
            throw new RuntimeException("Your stack is Empty");
        }
        convert();//做任何操作时都看一下能不能倒
        return popStack.pop();
    }
    
    public int peek(){
        if(popStack.empty()&&pushStack.empty()){
            throw new RuntimeException("Your stack is Empty");
        }
        convert();//做任何操作时都看一下能不能倒
    }
    
    public void convert(){
        if(popStack.isEmpty()){//只有pop栈为空时才倒
            while(!pushStack.isEmpty()){
                popStack.push(pushSatck.pop());
            }
        }
    }
}