3. (155) de pila mínimo

2020 21 de de marzo de

Diseñar una pila que empujan soportes, estallido, top, y recuperar el elemento mínimo en un tiempo constante.

• push (x) - Empuje elemento x en la pila.
• pop () - Elimina el elemento en la parte superior de la pila.
• superior () - Obtener el elemento superior.
• getMin () - Recuperar el elemento mínimo de la pila.

Ejemplo:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> Returns -3.
minStack.pop();
minStack.top();      --> Returns 0.
minStack.getMin();   --> Returns -2.

Un soporte diseñado para empujar, POP, funcionamiento superior, la pila puede ser recuperada y los elementos más pequeños de tiempo constante.

• empujan (x) - el elemento x empujan la pila.
• pop () - elementos de borrado de la pila.
• superior () - Obtiene el elemento superior.
• getMin () - recuperar el elemento mínimo de la pila.

Ejemplo:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

método 1

El método más directo es el uso de dos pilas, una pila del valor normal almacenado en la pila, la pila para mantener el otro mínimo es el mínimo de todos salvo el elemento actual con la parte superior de corriente de la pila, el proceso es el siguiente:

1. El primer elemento de la pila
2. Si el elemento recién añadido es mayor que la parte superior de la pila, entonces los elementos recién añadidos no se ocupará de
3. Si el elemento recién añadido es inferior a igual al elemento superior, el nuevo elemento en la pila
4. Pila de elementos no es igual al elemento superior no es operado
5. El elemento de la pila es igual al elemento superior, el elemento superior de la pila

class MinStack{
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    
    public MinStack(){
        stack=new Stack<>();
        minStack=new Stack<>();
    }
    
    public void push(int x){
        stack.push(x);
        if(!minStack.isEmpty()){
            int top=minStack.peek();
            //小于等于的时候才入栈
            if(x<=top){
                minStack.push(x);
            }
        }else{
            minStack.push(x);
        }
    }
    
    public void pop(){
        int pop=stack.pop();
        
        int top=minStack.peek();
        //等于的时候再出栈
        if(pop==top){
            minStack.pop();
        }
    }
    
    public int top(){
        return stack.peek();
    }
    
    public int getMin(){
        return minStack.peek();
    }
    
    public int getMin(){
        return minStack.peek();
    }
}

método 2

El método utiliza una implementación de dos pila, ahora tratar de lograr una pila, sólo una variable para guardar el valor mínimo, si el nuevo valor es empujado más pequeño, a continuación, antes de que se presiona el elemento nuevo en el original en la pila min y actualiza el valor mínimo

class minStack{
    int min = Integer.MIN_VALUE;
    Stack<Integer> stack = new Stack<Integer>();
    public void push(int x){
        if(x<=min){
            stack.push(min);
            min=x;
        }
        stack.push(x);
    }
    
    public void pop(){
        if(stack.pop()==min){
            min = stack.pop();
        }
    }
    
    public int top(){
        return stack.peek();
    }
    
    public int getMin(){
        return min;
    }
}

método 3

Como puede verse a partir del método, el problema clave a resolver cuando hay un nuevo valor más pequeño, el valor mínimo antes de cómo hacerlo?

Método 3 con otra idea, la diferencia mínima entre el valor actual y el valor mínimo almacenado en la pila por la memoria de pila min

public class MinStack{
    long min;
    Stack<long> stack;
    
    public MinStack(){
        stack=new Stack<>();
    }
    
    public void push(int x){
        if(stack.isEmpty()){
            min=x;
            stack.push(x-min);
        }else{
            stack.push(x-min);
            if(x<min){
                min=x;
            }
        }
    }
    
    public void pop(){
        if(stack.isEmpty()) return;
        long pop = stack.pop();
        if(pop<0){
            min=min-pop;
        }
    }
    
    public int top(){
        long top=stack.peek();
        if(top<0){
            return (int)(min);
        }else{
            return (int)(top+min);
        }
    }
    
    
    public int getMin(){
        return (int) min;
    }
}

Una desventaja de la solución anterior se guarda es la diferencia, puede causar desbordamiento, a fin de utilizar una gama más amplia de tipo long, esta actualización no requiere una solución mínima cuando el depósito mínimo antes de que ahorrar algo de espacio

método 4

pila java no se proporciona, aumento min en unión Nodo campo

class MinStack{
    class Node{
        int value;
        int min;
        Node next;
        
        Node(int x,int min){
            this.value=x;
            this.min=min;
            next=null;
        }
    }
    Node head;
    
    public void push(int x){
        if(null==head){
            head=new Node(x,x);
        }else{
            Node n = new Node(x,Math.min(x,head.min))
            n.next=head;
            head=n;
        }
    }
    
    public void pop(){
        if(head!=null)
            head=head.next;
    }
    
    public int top(){
        if(head!=null)
            return head.value;
        return -1;
    }
    
    public int getMin(){
        if(head!=null)
            return head.min;
        return -1;
    }
}