concevoir une pile telle que getMinimum () soit O (1)

118

C'est une question d'entrevue. Vous devez concevoir une pile qui contient une valeur entière telle que la fonction getMinimum () doit renvoyer l'élément minimum dans la pile.

Par exemple: considérez l'exemple ci-dessous

cas 1

5 -> HAUT
1
4
6
2

Lorsque getMinimum () est appelé, il doit renvoyer 1, qui est l'élément minimum 
dans la pile. 

cas # 2

stack.pop ()
stack.pop ()

Remarque: 5 et 1 sont sortis de la pile. Alors après ça, la pile
ressemble à,

4 -> HAUT
6
2

Lorsque getMinimum () est appelé, il doit retourner 2 qui est le minimum dans le 
empiler.

Constriants:

  1. getMinimum doit renvoyer la valeur minimale dans O (1)
  2. La contrainte d'espace doit également être prise en compte lors de sa conception et si vous utilisez un espace supplémentaire, il doit être d'espace constant.
Ganesh M
la source

Réponses:

180

EDIT: Cela échoue à la contrainte "espace constant" - cela double essentiellement l'espace requis. Je doute fort qu'il existe une solution qui ne fasse pas cela, sans gâcher quelque part la complexité d'exécution (par exemple, faire push / pop O (n)). Notez que cela ne change pas la complexité de l'espace requis, par exemple si vous avez une pile avec des exigences d'espace O (n), ce sera toujours O (n) avec un facteur constant différent.

Solution à espace non constant

Gardez une pile "dupliquée" de "minimum de toutes les valeurs inférieures dans la pile". Lorsque vous ouvrez la pile principale, faites également apparaître la pile min. Lorsque vous poussez la pile principale, appuyez soit sur le nouvel élément, soit sur le min courant, selon la valeur la plus basse. getMinimum()est alors implémenté comme juste minStack.peek().

Donc, en utilisant votre exemple, nous aurions:

Real stack        Min stack

5  --> TOP        1
1                 1
4                 2
6                 2
2                 2

Après avoir sauté deux fois, vous obtenez:

Real stack        Min stack

4                 2
6                 2
2                 2

Veuillez me faire savoir si ces informations ne sont pas suffisantes. C'est simple quand vous le grokez, mais cela peut prendre un peu de grattage au début :)

(L'inconvénient bien sûr est que cela double l'espace requis. Le temps d'exécution ne souffre pas de manière significative - c'est-à-dire qu'il est toujours de la même complexité.)

EDIT: Il y a une variante qui est un peu plus compliquée, mais qui a un meilleur espace en général. Nous avons toujours la pile min, mais nous n'en sortons que lorsque la valeur que nous sortons de la pile principale est égale à celle de la pile min. Nous ne poussons vers la pile min que lorsque la valeur poussée sur la pile principale est inférieure ou égale à la valeur min actuelle. Cela permet de dupliquer les valeurs minimales. getMinimum()est encore juste une opération de coup d'oeil. Par exemple, en prenant la version originale et en poussant à nouveau 1, nous obtiendrions:

Real stack        Min stack

1  --> TOP        1
5                 1
1                 2
4                 
6                 
2                 

Popping à partir de ce qui précède apparaît des deux piles car 1 == 1, laissant:

Real stack        Min stack

5  --> TOP        1
1                 2
4                 
6                 
2                 

Le pop à nouveau n'apparaît que de la pile principale, car 5> 1:

Real stack        Min stack

1                 1
4                 2
6                 
2                 

Popping à nouveau fait apparaître les deux piles car 1 == 1:

Real stack        Min stack

4                 2
6                 
2                 

Cela aboutit à la même complexité d'espace dans le pire des cas (le double de la pile d'origine) mais une bien meilleure utilisation de l'espace si nous obtenons rarement un "nouveau minimum ou égal".

EDIT: Voici une mise en œuvre du plan diabolique de Pete. Je ne l'ai pas testé à fond, mais je pense que ça va :)

using System.Collections.Generic;

public class FastMinStack<T>
{
    private readonly Stack<T> stack = new Stack<T>();
    // Could pass this in to the constructor
    private readonly IComparer<T> comparer = Comparer<T>.Default;

    private T currentMin;

    public T Minimum
    {
        get { return currentMin; }
    }

    public void Push(T element)
    {
        if (stack.Count == 0 ||
            comparer.Compare(element, currentMin) <= 0)
        {
            stack.Push(currentMin);
            stack.Push(element);
            currentMin = element;
        }
        else
        {
            stack.Push(element);
        }
    }

    public T Pop()
    {
        T ret = stack.Pop();
        if (comparer.Compare(ret, currentMin) == 0)
        {
            currentMin = stack.Pop();
        }
        return ret;
    }
}
Jon Skeet
la source
3
Intelligent! @Ganesh: Pourquoi le runtime serait-il un problème? Cela ne prendra que deux fois plus de temps qu'une seule pile, c'est-à-dire qu'il est toujours temps O (1) pour push () et pop () ainsi que pour getMinimum () - c'est une excellente performance!
j_random_hacker
4
Si vous avez une seule variable, que se passe-t-il lorsque vous affichez le «1» dans votre exemple? Il faut comprendre que le minimum précédent était "2" - ce qu'il ne peut pas sans tout parcourir.
Jon Skeet
1
@Ganesh: N'auriez-vous pas alors besoin de trouver le nouveau minimum en utilisant une recherche O (n) chaque fois que vous pop ()?
j_random_hacker
2
Juste en lisant vos autres commentaires, quand vous dites "dans la conception de la pile elle-même", voulez-vous dire "dans chaque élément"? Si tel est le cas, vous doublez potentiellement encore les besoins en mémoire, en fonction de la taille du type d'élément. C'est conceptuellement la même chose que deux piles.
Jon Skeet
1
@Ganesh: Malheureusement, ne pas avoir de pile supplémentaire signifie que nous ne pouvons pas faire l'optimisation d'économie d'espace que j'ai incluse ci-dessus. Garder ensemble «minimum et élément» est probablement plus efficace que deux piles de même taille (moins de frais généraux - tableaux, nœuds de liste, etc.) bien que cela dépende de la langue.
Jon Skeet
41

Ajoutez un champ pour contenir la valeur minimale et mettez-le à jour pendant Pop () et Push (). De cette façon, getMinimum () sera O (1), mais Pop () et Push () devront faire un peu plus de travail.

Si la valeur minimale est sautée, Pop () sera O (n), sinon ils seront toujours tous les deux O (1). Lors du redimensionnement, Push () devient O (n) selon l'implémentation de Stack.

Voici une mise en œuvre rapide

public sealed class MinStack {
    private int MinimumValue;
    private readonly Stack<int> Stack = new Stack<int>();

    public int GetMinimum() {
        if (IsEmpty) {
            throw new InvalidOperationException("Stack is empty");
        }
        return MinimumValue;
    }

    public int Pop() {
        var value = Stack.Pop();
        if (value == MinimumValue) {
            MinimumValue = Stack.Min();
        }
        return value;
    }

    public void Push(int value) {
        if (IsEmpty || value < MinimumValue) {
            MinimumValue = value;
        }
        Stack.Push(value);
    }

    private bool IsEmpty { get { return Stack.Count() == 0; } }
}
Brian Rasmussen
la source
désolé je n'ai pas compris pourquoi pop () et push () souffriront?
Ganesh M
11
Dans pop (), le "nouvel" élément minimum doit être trouvé, ce qui prend O (n). Push () ne souffrira pas, car cette opération est toujours O (1).
Georg Schölly
4
@sigjuice: correct. Je pense que je vais changer le mot «souffrir» en quelque chose de moins dramatique :)
Brian Rasmussen
2
@Ganesh M "le champ d'addition des éléments" si vous avez un champ supplémentaire dans vos N éléments, ce n'est pas un espace constant, mais O (N) supplémentaire.
Pete Kirkham
1
Si la valeur minimale est sortie de la pile pendant une opération, comment trouver la valeur minimale suivante? Cette méthode ne prend pas en charge ce scénario ...
Sharat Chandra
16
public class StackWithMin {
    int min;
    int size;
    int[] data = new int[1024];

    public void push ( int val ) {
        if ( size == 0 ) {
            data[size] = val;
            min = val;
        } else if ( val < min) {
            data[size] = 2 * val - min;
            min = val;

            assert (data[size] < min); 
        } else {
            data[size] = val;
        }

        ++size;

        // check size and grow array
    }

    public int getMin () {
        return min;
    }

    public int pop () {
        --size;

        int val = data[size];

        if ( ( size > 0 ) && ( val < min ) ) {
            int prevMin = min;
            min += min - val;
            return prevMin;
        } else {
            return val;
        }
    }

    public boolean isEmpty () {
        return size == 0;
    }

    public static void main (String...args) {
        StackWithMin stack = new StackWithMin();

        for ( String arg: args ) 
            stack.push( Integer.parseInt( arg ) );

        while ( ! stack.isEmpty() ) {
            int min = stack.getMin();
            int val = stack.pop();

            System.out.println( val + " " + min );
        }

        System.out.println();
    }

}

Il stocke explicitement le minimum actuel, et si le minimum change, au lieu de pousser la valeur, il pousse une valeur de la même différence de l'autre côté du nouveau minimum (si min = 7 et que vous appuyez sur 5, il pousse 3 à la place (5- | 7-5 | = 3) et définit min à 5; si vous pop 3 quand min est 5, il voit que la valeur popped est inférieure à min, donc inverse la procédure pour obtenir 7 pour le nouveau min, puis retourne le précédent min). Comme toute valeur qui n'entraîne pas de changement, le minimum actuel est supérieur au minimum actuel, vous avez quelque chose qui peut être utilisé pour différencier les valeurs qui changent le minimum et celles qui ne le font pas.

Dans les langages qui utilisent des entiers de taille fixe, vous empruntez un peu d'espace à la représentation des valeurs, de sorte que cela risque de déborder et que l'assertion échouera. Mais sinon, c'est un espace supplémentaire constant et toutes les opérations sont toujours O (1).

Les piles basées sur des listes chaînées ont d'autres emplacements auxquels vous pouvez emprunter un peu, par exemple en C le bit le moins significatif du pointeur suivant, ou en Java le type des objets dans la liste chaînée. Pour Java, cela signifie qu'il y a plus d'espace utilisé par rapport à une pile contiguë, car vous avez la surcharge d'objet par lien:

public class LinkedStackWithMin {
    private static class Link {
        final int value;
        final Link next;

        Link ( int value, Link next ) {
            this.value = value;
            this.next = next;
        }

        int pop ( LinkedStackWithMin stack ) {
            stack.top = next;
            return value;
        }
    }

    private static class MinLink extends Link {
        MinLink ( int value, Link next ) {
            super( value, next );
        }

        int pop ( LinkedStackWithMin stack ) {
            stack.top = next;
            int prevMin = stack.min;
            stack.min = value;
            return prevMin;
        }
    }

    Link top;
    int min;

    public LinkedStackWithMin () {
    }

    public void push ( int val ) {
        if ( ( top == null ) || ( val < min ) ) {
            top = new MinLink(min, top);
            min = val;
        } else {
            top = new Link(val, top);
        }
    }

    public int pop () {
        return top.pop(this);
    }

    public int getMin () {
        return min;
    }

    public boolean isEmpty () {
        return top == null;
    }

En C, la surcharge n'est pas là, et vous pouvez emprunter le lsb du pointeur suivant:

typedef struct _stack_link stack_with_min;

typedef struct _stack_link stack_link;

struct _stack_link {
    size_t  next;
    int     value;
};

stack_link* get_next ( stack_link* link ) 
{
    return ( stack_link * )( link -> next & ~ ( size_t ) 1 );
}

bool is_min ( stack_link* link )
{
    return ( link -> next & 1 ) ! = 0;
}

void push ( stack_with_min* stack, int value )
{
    stack_link *link = malloc ( sizeof( stack_link ) );

    link -> next = ( size_t ) stack -> next;

    if ( (stack -> next == 0) || ( value == stack -> value ) ) {
        link -> value = stack -> value;
        link -> next |= 1; // mark as min
    } else {
        link -> value = value;
    }

    stack -> next = link;
}

etc.;

Cependant, aucun de ceux-ci n'est vraiment O (1). Ils ne nécessitent plus d'espace en pratique, car ils exploitent des trous dans les représentations de nombres, d'objets ou de pointeurs dans ces langages. Mais une machine théorique qui utilisait une représentation plus compacte exigerait un bit supplémentaire à ajouter à cette représentation dans chaque cas.

Pete Kirkham
la source
+1 très élégant en effet ... Version C ++ trivialement portée fonctionnant chez ideone ici . À votre santé.
Tony Delroy
En Java, cela produira un résultat erroné pop()si la dernière valeur poussée était Integer.MIN_VALUE(par exemple, push 1, push Integer.MIN_VALUE, pop). Cela est dû au sous-débordement comme mentionné ci-dessus. Sinon, fonctionne pour toutes les valeurs entières.
Theo
13

J'ai trouvé une solution qui satisfait toutes les contraintes mentionnées (opérations à temps constant) et espace supplémentaire constant .

L'idée est de stocker la différence entre la valeur min et le nombre d'entrée, et de mettre à jour la valeur min si elle n'est plus la valeur minimale.

Le code est comme suit:

public class MinStack {
    long min;
    Stack<Long> stack;

    public MinStack(){
        stack = new Stack<>();
    }

    public void push(int x) {
        if (stack.isEmpty()) {
            stack.push(0L);
            min = x;
        } else {
            stack.push(x - min); //Could be negative if min value needs to change
            if (x < min) min = x;
        }
    }

    public int pop() {
        if (stack.isEmpty()) return;

        long pop = stack.pop();

        if (pop < 0) {
            long ret = min
            min = min - pop; //If negative, increase the min value
            return (int)ret;
        }
        return (int)(pop + min);

    }

    public int top() {
        long top = stack.peek();
        if (top < 0) {
            return (int)min;
        } else {
           return (int)(top + min);
        }
    }

    public int getMin() {
        return (int)min;
    }
}

Le crédit va à: https://leetcode.com/discuss/15679/share-my-java-solution-with-only-one-stack

WoLfPwNeR
la source
Celui-ci fonctionne. J'ai également essayé avec des nombres négatifs dans la pile. Et assez simple à retenir aussi. Merci.
r9891
7

Eh bien, quelles sont les contraintes d'exécution de pushet pop? S'ils ne sont pas tenus d'être constants, calculez simplement la valeur minimale de ces deux opérations (en les rendant O ( n )). Sinon, je ne vois pas comment cela peut être fait avec un espace supplémentaire constant.

Konrad Rudolph
la source
4
+1, hehe ... Le vieux truc de "plier les règles" ... De la même manière, je connais un algorithme de tri qui trie n'importe quel tableau de taille en temps O (1), mais le premier accès à n'importe quel élément du le résultat entraîne O (nlog n) overhead ... :)
j_random_hacker
3
À Haskell, tout est en temps constant! (sauf si vous souhaitez imprimer le résultat)
Henk
1
+1 pour avoir noté la mauvaise spécification du problème. "Je ne vois pas comment cela peut être fait" - moi non plus, mais la solution de Pete Kirkham le fait très élégamment ....
Tony Delroy
1

Voici mon code qui fonctionne avec O (1). Le code précédent que j'ai publié avait un problème lorsque l'élément minimum est apparu. J'ai modifié mon code. Celui-ci utilise une autre pile qui maintient l'élément minimum présent dans la pile au-dessus de l'élément poussé actuel.

 class StackDemo
{
    int[] stk = new int[100];
    int top;
    public StackDemo()
    {
        top = -1;
    }
    public void Push(int value)
    {
        if (top == 100)
            Console.WriteLine("Stack Overflow");
        else
            stk[++top] = value;
    }
    public bool IsEmpty()
    {
        if (top == -1)
            return true;
        else
            return false;
    }
    public int Pop()
    {
        if (IsEmpty())
        {
            Console.WriteLine("Stack Underflow");
            return 0;
        }
        else
            return stk[top--];
    }
    public void Display()
    {
        for (int i = top; i >= 0; i--)
            Console.WriteLine(stk[i]);
    }
}
class MinStack : StackDemo
{
    int top;
    int[] stack = new int[100];
    StackDemo s1; int min;
    public MinStack()
    {
        top = -1;
        s1 = new StackDemo();
    }
    public void PushElement(int value)
    {
        s1.Push(value);
        if (top == 100)
            Console.WriteLine("Stack Overflow");
        if (top == -1)
        {
            stack[++top] = value;
            stack[++top] = value;   
        }
        else
        {
            //  stack[++top]=value;
            int ele = PopElement();
            stack[++top] = ele;
            int a = MininmumElement(min, value);
              stack[++top] = min;

                stack[++top] = value;
                stack[++top] = a;


        }
    }
    public int PopElement()
    {

        if (top == -1)
            return 1000;
        else
        {
            min = stack[top--];
            return stack[top--];
        }

    }
    public int PopfromStack()
    {
        if (top == -1)
            return 1000;
        else
        {
            s1.Pop();
            return PopElement();
        }
    }
    public int MininmumElement(int a,int b)
    {
        if (a > b)
            return b;
        else
            return a;
    }
    public int StackTop()
    {
        return stack[top];
    }
    public void DisplayMinStack()
    {
        for (int i = top; i >= 0; i--)
            Console.WriteLine(stack[i]);
    }
}
class Program
{
    static void Main(string[] args)
    {
        MinStack ms = new MinStack();
        ms.PushElement(15);
        ms.PushElement(2);
        ms.PushElement(1);
        ms.PushElement(13);
        ms.PushElement(5);
        ms.PushElement(21);
        Console.WriteLine("Min Stack");
        ms.DisplayMinStack();
        Console.WriteLine("Minimum Element:"+ms.StackTop());
        ms.PopfromStack();
        ms.PopfromStack();
        ms.PopfromStack();
        ms.PopfromStack();

        Console.WriteLine("Min Stack");
        ms.DisplayMinStack();
        Console.WriteLine("Minimum Element:" + ms.StackTop());
        Thread.Sleep(1000000);
    }
}
Akshay
la source
3
Veuillez mentionner le langage de programmation utilisé ici pour écrire du code. Cela aide les visiteurs potentiels à comprendre ce qui se passe en fonction de la syntaxe. Je suppose que c'est C # mais que faire si quelqu'un ne le fait pas?
realPK
1

J'ai utilisé un autre type de pile. Voici la mise en œuvre.

//
//  main.cpp
//  Eighth
//
//  Created by chaitanya on 4/11/13.
//  Copyright (c) 2013 cbilgika. All rights reserved.
//

#include <iostream>
#include <limits>
using namespace std;
struct stack
{
    int num;
    int minnum;
}a[100];

void push(int n,int m,int &top)
{

    top++;
    if (top>=100) {
        cout<<"Stack Full";
        cout<<endl;
    }
    else{
        a[top].num = n;
        a[top].minnum = m;
    }


}

void pop(int &top)
{
    if (top<0) {
        cout<<"Stack Empty";
        cout<<endl;
    }
    else{
       top--; 
    }


}
void print(int &top)
{
    cout<<"Stack: "<<endl;
    for (int j = 0; j<=top ; j++) {
        cout<<"("<<a[j].num<<","<<a[j].minnum<<")"<<endl;
    }
}


void get_min(int &top)
{
    if (top < 0)
    {
        cout<<"Empty Stack";
    }
    else{
        cout<<"Minimum element is: "<<a[top].minnum;
    }
    cout<<endl;
}

int main()
{

    int top = -1,min = numeric_limits<int>::min(),num;
    cout<<"Enter the list to push (-1 to stop): ";
    cin>>num;
    while (num!=-1) {
        if (top == -1) {
            min = num;
            push(num, min, top);
        }
        else{
            if (num < min) {
                min = num;
            }
            push(num, min, top);
        }
        cin>>num;
    }
    print(top);
    get_min(top);
    return 0;
}

Production:

Enter the list to push (-1 to stop): 5
1
4
6
2
-1
Stack: 
(5,5)
(1,1)
(4,1)
(6,1)
(2,1)
Minimum element is: 1

Essayez-le. Je pense que cela répond à la question. Le deuxième élément de chaque paire donne la valeur minimale vue lorsque cet élément a été inséré.

Chaitanya Bilgikar
la source
1

Je poste le code complet ici pour trouver le minimum et le maximum dans une pile donnée.

La complexité temporelle sera O (1).

package com.java.util.collection.advance.datastructure;

/**
 * 
 * @author vsinha
 *
 */
public abstract interface Stack<E> {

    /**
     * Placing a data item on the top of the stack is called pushing it
     * @param element
     * 
     */
    public abstract void push(E element);


    /**
     * Removing it from the top of the stack is called popping it
     * @return the top element
     */
    public abstract E pop();

    /**
     * Get it top element from the stack and it 
     * but the item is not removed from the stack, which remains unchanged
     * @return the top element
     */
    public abstract E peek();

    /**
     * Get the current size of the stack.
     * @return
     */
    public abstract int size();


    /**
     * Check whether stack is empty of not.
     * @return true if stack is empty, false if stack is not empty
     */
    public abstract boolean empty();



}



package com.java.util.collection.advance.datastructure;

@SuppressWarnings("hiding")
public abstract interface MinMaxStack<Integer> extends Stack<Integer> {

    public abstract int min();

    public abstract int max();

}


package com.java.util.collection.advance.datastructure;

import java.util.Arrays;

/**
 * 
 * @author vsinha
 *
 * @param <E>
 */
public class MyStack<E> implements Stack<E> {

    private E[] elements =null;
    private int size = 0;
    private int top = -1;
    private final static int DEFAULT_INTIAL_CAPACITY = 10;


    public MyStack(){
        // If you don't specify the size of stack. By default, Stack size will be 10
        this(DEFAULT_INTIAL_CAPACITY);
    }

    @SuppressWarnings("unchecked")
    public MyStack(int intialCapacity){
        if(intialCapacity <=0){
            throw new IllegalArgumentException("initial capacity can't be negative or zero");
        }
        // Can't create generic type array
        elements =(E[]) new Object[intialCapacity];
    }

    @Override
    public void push(E element) {
        ensureCapacity();
        elements[++top] = element;
        ++size;
    }

    @Override
    public E pop() {
        E element = null;
        if(!empty()) {
            element=elements[top];
            // Nullify the reference
            elements[top] =null;
            --top;
            --size;
        }
        return element;
    }

    @Override
    public E peek() {
        E element = null;
        if(!empty()) {
            element=elements[top];
        }
        return element;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean empty() {
        return size == 0;
    }

    /**
     * Increases the capacity of this <tt>Stack by double of its current length</tt> instance, 
     * if stack is full 
     */
    private void ensureCapacity() {
        if(size != elements.length) {
            // Don't do anything. Stack has space.
        } else{
            elements = Arrays.copyOf(elements, size *2);
        }
    }

    @Override
    public String toString() {
        return "MyStack [elements=" + Arrays.toString(elements) + ", size="
                + size + ", top=" + top + "]";
    }


}


package com.java.util.collection.advance.datastructure;

/**
 * Time complexity will be O(1) to find min and max in a given stack.
 * @author vsinha
 *
 */
public class MinMaxStackFinder extends MyStack<Integer> implements MinMaxStack<Integer> {

    private MyStack<Integer> minStack;

    private MyStack<Integer> maxStack;

    public MinMaxStackFinder (int intialCapacity){
        super(intialCapacity);
        minStack =new MyStack<Integer>();
        maxStack =new MyStack<Integer>();

    }
    public void push(Integer element) {
        // Current element is lesser or equal than min() value, Push the current element in min stack also.
        if(!minStack.empty()) {
            if(min() >= element) {
                minStack.push(element);
            }
        } else{
            minStack.push(element);
        }
        // Current element is greater or equal than max() value, Push the current element in max stack also.
        if(!maxStack.empty()) {
            if(max() <= element) {
                maxStack.push(element);
            }
        } else{
            maxStack.push(element);
        }
        super.push(element);
    }


    public Integer pop(){
        Integer curr = super.pop();
        if(curr !=null) {
            if(min() == curr) {
                minStack.pop();
            } 

            if(max() == curr){
                maxStack.pop();
            }
        }
        return curr;
    }


    @Override
    public int min() {
        return minStack.peek();
    }

    @Override
    public int max() {
        return maxStack.peek();
    }


    @Override
    public String toString() {
        return super.toString()+"\nMinMaxStackFinder [minStack=" + minStack + "\n maxStack="
                + maxStack + "]" ;
    }




}

// You can use the below program to execute it.

package com.java.util.collection.advance.datastructure;

import java.util.Random;

public class MinMaxStackFinderApp {

    public static void main(String[] args) {
        MinMaxStack<Integer> stack =new MinMaxStackFinder(10);
        Random random =new Random();
        for(int i =0; i< 10; i++){
            stack.push(random.nextInt(100));
        }
        System.out.println(stack);
        System.out.println("MAX :"+stack.max());
        System.out.println("MIN :"+stack.min());

        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();

        System.out.println(stack);
        System.out.println("MAX :"+stack.max());
        System.out.println("MIN :"+stack.min());
    }
}

Faites-moi savoir si vous rencontrez un problème

Merci, Vikash

bébé java
la source
1

Vous pouvez étendre votre classe de pile d'origine et y ajouter simplement le suivi minimum. Laissez la classe parent d'origine gérer tout le reste comme d'habitude.

public class StackWithMin extends Stack<Integer> {  

    private Stack<Integer> min;

    public StackWithMin() {
        min = new Stack<>();
    }

    public void push(int num) {
        if (super.isEmpty()) {
            min.push(num);
        } else if (num <= min.peek()) {
            min.push(num);
        }
        super.push(num);
    }

    public int min() {
        return min.peek();
    }

    public Integer pop() {
        if (super.peek() == min.peek()) {
            min.pop();
        }
        return super.pop();
    }   
}
Arcturus
la source
Cette solution utilise également un espace supplémentaire en termes de Stack <Integer> min.
Arpit
1

Voici ma solution en java en utilisant la liste aimée.

class Stack{
    int min;
    Node top;
    static class Node{
        private int data;
        private Node next;
        private int min;

        Node(int data, int min){
           this.data = data;
           this.min = min;
           this.next = null; 
    }
}

  void push(int data){
        Node temp;
        if(top == null){
            temp = new Node(data,data);
            top = temp;
            top.min = data;
        }
        if(top.min > data){
            temp = new Node(data,data);
            temp.next = top;
            top = temp;
        } else {
            temp = new Node(data, top.min);
            temp.next = top;
            top = temp;
        }
  }

  void pop(){
    if(top != null){
        top = top.next;
    }
  }

  int min(){
    return top.min;
  }

}

Irshad ck
la source
1

Supposons que la pile sur laquelle nous allons travailler est la suivante:

6 , minvalue=2
2 , minvalue=2
5 , minvalue=3
3 , minvalue=3
9 , minvalue=7
7 , minvalue=7
8 , minvalue=8

Dans la représentation ci-dessus, la pile n'est construite que par la valeur gauche, la valeur [minvalue] de droite est écrite uniquement à des fins d'illustration qui sera stockée dans une variable.

Le problème réel est lorsque la valeur qui est la valeur minimale est supprimée à ce stade, comment pouvons-nous savoir quel est le prochain élément minimum sans itérer sur la pile.

Comme par exemple dans notre pile lorsque 6 get apparaît, nous savons que ce n'est pas l'élément minimum car l'élément minimum est 2, nous pouvons donc le supprimer en toute sécurité sans mettre à jour notre valeur min.

Mais lorsque nous pop 2, nous pouvons voir que la valeur minimale est de 2 pour le moment et si cela apparaît, nous devons mettre à jour la valeur minimale à 3.

Point1:

Maintenant, si vous observez attentivement, nous devons générer minvalue = 3 à partir de cet état particulier [2, minvalue = 2]. ou si vous allez depper dans la pile, nous devons générer minvalue = 7 à partir de cet état particulier [3, minvalue = 3] ou si vous allez plus loin dans la pile, nous devons générer minvalue = 8 à partir de cet état particulier [7, minvalue = 7]

Avez-vous remarqué quelque chose en commun dans tous les 3 cas ci-dessus, la valeur que nous devons générer dépend de deux variables qui sont toutes deux égales. Correct. Pourquoi cela se produit-il parce que lorsque nous poussons un élément plus petit que la valeur minimale actuelle, nous poussons essentiellement cet élément dans la pile et mettons également à jour le même nombre dans la valeur minimale.

Point2:

Nous stockons donc essentiellement un double du même nombre une fois dans la pile et une fois dans la variable minvalue. Nous devons nous concentrer pour éviter cette duplication et stocker des données utiles dans la pile ou la valeur min pour générer le minimum précédent, comme indiqué dans CASES ci-dessus.

Concentrons-nous sur ce que nous devons stocker dans la pile lorsque la valeur à stocker dans push est inférieure à la valeur minmum. Appelons cette variable y, donc maintenant notre pile ressemblera à ceci:

6 , minvalue=2
y1 , minvalue=2
5 , minvalue=3
y2 , minvalue=3
9 , minvalue=7
y3 , minvalue=7
8 , minvalue=8

Je les ai renommés y1, y2, y3 pour éviter toute confusion selon laquelle tous auront la même valeur.

Point3:

Essayons maintenant de trouver des contraintes sur y1, y2 et y3. Vous souvenez-vous quand exactement nous avons besoin de mettre à jour la valeur min en faisant pop (), seulement quand nous avons sauté l'élément qui est égal à la valeur min. Si nous affichons quelque chose de plus grand que la valeur minimale, nous n'avons pas besoin de mettre à jour la valeur minimale. Donc, pour déclencher la mise à jour de la valeur min, y1, y2 et y3 doivent être plus petits que la valeur min correspondante. [Nous avodons l'égalité pour éviter la duplication [Point2]] donc la contrainte est [y <minValue].

Revenons maintenant à peupler y, nous devons générer une valeur et mettre y au moment du push, rappelez-vous. Prenons la valeur qui vient pour push pour être x qui est inférieure à la prevMinvalue, et la valeur que nous allons réellement pousser dans la pile pour être y. Une chose est donc évidente: newMinValue = x et y <newMinvalue.

Maintenant, nous devons calculer y (rappelez-vous que y peut être n'importe quel nombre inférieur à newMinValue (x), nous devons donc trouver un nombre qui puisse remplir notre contrainte) à l'aide de prevMinvalue et x (newMinvalue).

Let's do the math:
    x < prevMinvalue [Given]
    x - prevMinvalue < 0 
    x - prevMinValue + x < 0 + x [Add x on both side]
    2*x - prevMinValue < x      
this is the y which we were looking for less than x(newMinValue).
y = 2*x - prevMinValue. 'or' y = 2*newMinValue - prevMinValue 'or' y = 2*curMinValue - prevMinValue [taking curMinValue=newMinValue].

Donc, au moment de pousser x s'il est inférieur à prevMinvalue, nous poussons y [2 * x-prevMinValue] et mettons à jour newMinValue = x.

Et au moment du pop, si la pile contient quelque chose de moins que la minValue, c'est notre déclencheur pour mettre à jour le minVAlue. Nous devons calculer prevMinValue à partir de curMinValue et y. y = 2 * curMinValue - prevMinValue [Prouvé] prevMinVAlue = 2 * curMinvalue - y.

2 * curMinValue - y est le nombre que nous devons mettre à jour maintenant vers prevMinValue.

Le code pour la même logique est partagé ci-dessous avec la complexité du temps O (1) et de l'espace O (1).

// C++ program to implement a stack that supports 
// getMinimum() in O(1) time and O(1) extra space. 
#include <bits/stdc++.h> 
using namespace std; 

// A user defined stack that supports getMin() in 
// addition to push() and pop() 
struct MyStack 
{ 
    stack<int> s; 
    int minEle; 

    // Prints minimum element of MyStack 
    void getMin() 
    { 
        if (s.empty()) 
            cout << "Stack is empty\n"; 

        // variable minEle stores the minimum element 
        // in the stack. 
        else
            cout <<"Minimum Element in the stack is: "
                 << minEle << "\n"; 
    } 

    // Prints top element of MyStack 
    void peek() 
    { 
        if (s.empty()) 
        { 
            cout << "Stack is empty "; 
            return; 
        } 

        int t = s.top(); // Top element. 

        cout << "Top Most Element is: "; 

        // If t < minEle means minEle stores 
        // value of t. 
        (t < minEle)? cout << minEle: cout << t; 
    } 

    // Remove the top element from MyStack 
    void pop() 
    { 
        if (s.empty()) 
        { 
            cout << "Stack is empty\n"; 
            return; 
        } 

        cout << "Top Most Element Removed: "; 
        int t = s.top(); 
        s.pop(); 

        // Minimum will change as the minimum element 
        // of the stack is being removed. 
        if (t < minEle) 
        { 
            cout << minEle << "\n"; 
            minEle = 2*minEle - t; 
        } 

        else
            cout << t << "\n"; 
    } 

    // Removes top element from MyStack 
    void push(int x) 
    { 
        // Insert new number into the stack 
        if (s.empty()) 
        { 
            minEle = x; 
            s.push(x); 
            cout <<  "Number Inserted: " << x << "\n"; 
            return; 
        } 

        // If new number is less than minEle 
        if (x < minEle) 
        { 
            s.push(2*x - minEle); 
            minEle = x; 
        } 

        else
           s.push(x); 

        cout <<  "Number Inserted: " << x << "\n"; 
    } 
}; 

// Driver Code 
int main() 
{ 
    MyStack s; 
    s.push(3); 
    s.push(5); 
    s.getMin(); 
    s.push(2); 
    s.push(1); 
    s.getMin(); 
    s.pop(); 
    s.getMin(); 
    s.pop(); 
    s.peek(); 

    return 0; 
} 
Rajat Gautam
la source
0

Voici ma version d'implémentation.

 struct MyStack {
    élément int;
    int * CurrentMiniAddress;
 };

 void Push (valeur int)
 {
    // Créez votre structure et remplissez la valeur
    MyStack S = nouveau MyStack ();
    S-> élément = valeur;

    si (Stack.Empty ())
    {    
        // Puisque la pile est vide, pointez CurrentMiniAddress sur elle-même
        S-> CurrentMiniAddress = S;

    }
    autre
    {
         // La pile n'est pas vide

         // Récupère l'élément supérieur. Pas de pop ()
         MyStack * TopElement = Stack.Top ();

         // Rappelez-vous toujours que l'élément TOP pointe vers le
         // élément minimum dans toute la pile
         if (élément S-> élément CurrentMiniAddress->)
         {
            // Si la valeur actuelle est le minimum dans toute la pile
            // alors S pointe sur lui-même
            S-> CurrentMiniAddress = S;
         }
             autre
             {
                 // Donc ce n'est pas le minimum dans toute la pile
                 // Pas de soucis, TOP tient l'élément minimum
                 S-> CurrentMiniAddress = TopElement-> CurrentMiniAddress;
             }

    }
        Stack.Add (S);
 }

 vide Pop ()
 {
     if (! Stack.Empty ())
     {
        Stack.Pop ();
     }  
 }

 int GetMinimum (pile et pile)
 {
       if (! stack.Empty ())
       {
            MyStack * Top = stack.top ();
            // Top pointe toujours vers le minimumx
            return Top-> CurrentMiniAddress-> element;
        }
 }
Ganesh M
la source
J'accepte, cela nécessite un élément supplémentaire dans votre structure. Mais cela élimine la recherche du minimum chaque fois que nous faisons apparaître un élément.
Ganesh M
1
Alors, n'ayant pas réussi à répondre aux contraintes de la question, avez-vous obtenu le poste?
Pete Kirkham
0
#include<stdio.h>
struct stack
{
    int data;
    int mindata;
}a[100];

void push(int *tos,int input)
{
    if (*tos > 100)
    {
        printf("overflow");
        return;
    }
    (*tos)++;
    a[(*tos)].data=input;
    if (0 == *tos)
        a[*tos].mindata=input;
    else if (a[*tos -1].mindata < input)
        a[*tos].mindata=a[*tos -1].mindata;
    else
        a[*tos].mindata=input;
}

int pop(int * tos)
{
    if (*tos <= -1)
    {
        printf("underflow");
        return -1;
    }
    return(a[(*tos)--].data);
}
void display(int tos)
{
    while (tos > -1)
    {
        printf("%d:%d\t",a[tos].data,a[tos].mindata);
        tos--;
    }    
}

int min(int tos)
{
   return(a[tos].mindata);
}
int main()
{
int tos=-1,x,choice;
while(1)
{
    printf("press 1-push,2-pop,3-mindata,4-display,5-exit ");
    scanf("%d",&choice);
    switch(choice)
    {
    case 1: printf("enter data to push");
            scanf("%d",&x);
            push(&tos,x);
            break;
    case 2: printf("the poped out data=%d ",pop(&tos));
            break;
    case 3: printf("The min peeped data:%d",min(tos));
            break;
    case 4: printf("The elements of stack \n");
            display(tos);
            break;
    default: exit(0);
}
}
tauqir azam
la source
0

J'ai trouvé cette solution ici

struct StackGetMin {
  void push(int x) {
    elements.push(x);
    if (minStack.empty() || x <= minStack.top())
      minStack.push(x);
  }
  bool pop() {
    if (elements.empty()) return false;
    if (elements.top() == minStack.top())
      minStack.pop();
    elements.pop();
    return true;
  }
  bool getMin(int &min) {
    if (minStack.empty()) {
      return false;
    } else {
      min = minStack.top();
      return true;
    }
  }
  stack<int> elements;
  stack<int> minStack;
};
isxaker
la source
0
struct Node {
    let data: Int
    init(_ d:Int){
        data = d
    }
}

struct Stack {
    private var backingStore = [Node]()
    private var minArray = [Int]()

    mutating func push(n:Node) {
        backingStore.append(n)
        minArray.append(n.data)
        minArray.sort(>)
        minArray
    }

    mutating func pop() -> Node? {
        if(backingStore.isEmpty){
            return nil
        }

        let n = backingStore.removeLast()

        var found = false
        minArray = minArray.filter{
            if (!found && $0 == n.data) {
                found = true
                return false
            }
            return true
        }
        return n
    }

    func min() -> Int? {
        return minArray.last
    }
}
Edward Ashak
la source
0
 class MyStackImplementation{
private final int capacity = 4;
int min;
int arr[] = new int[capacity];
int top = -1;

public void push ( int val ) {
top++;
if(top <= capacity-1){
    if(top == 0){
min = val;
arr[top] = val;
}
else if(val < min){
arr[top] = arr[top]+min;
min = arr[top]-min;
arr[top] = arr[top]-min;
}
else {
arr[top] = val;
}
System.out.println("element is pushed");
}
else System.out.println("stack is full");

}

 public void pop () {
top--;
   if(top > -1){ 

   min = arr[top];
}
else {min=0; System.out.println("stack is under flow");}

}
public int min(){
return min;
}

 public boolean isEmpty () {
    return top == 0;
}

public static void main(String...s){
MyStackImplementation msi = new MyStackImplementation();
msi.push(1);
msi.push(4);
msi.push(2);
msi.push(10);
System.out.println(msi.min);
msi.pop();
msi.pop();
msi.pop();
msi.pop();
msi.pop();
System.out.println(msi.min);

}
}
mayank
la source
0
class FastStack {

    private static class StackNode {
        private Integer data;
        private StackNode nextMin;

        public StackNode(Integer data) {
            this.data = data;
        }

        public Integer getData() {
            return data;
        }

        public void setData(Integer data) {
            this.data = data;
        }

        public StackNode getNextMin() {
            return nextMin;
        }

        public void setNextMin(StackNode nextMin) {
            this.nextMin = nextMin;
        }

    }

    private LinkedList<StackNode> stack = new LinkedList<>();

    private StackNode currentMin = null;

    public void push(Integer item) {
        StackNode node = new StackNode(item);
        if (currentMin == null) {
            currentMin = node;
            node.setNextMin(null);
        } else if (item < currentMin.getData()) {
            StackNode oldMinNode = currentMin;
            node.setNextMin(oldMinNode);
            currentMin = node;
        }

        stack.addFirst(node);
    }

    public Integer pop() {
        if (stack.isEmpty()) {
            throw new EmptyStackException();
        }
        StackNode node = stack.peek();
        if (currentMin == node) {
            currentMin = node.getNextMin();
        }
        stack.removeFirst();
        return node.getData();
    }

    public Integer getMinimum() {
        if (stack.isEmpty()) {
            throw new NoSuchElementException("Stack is empty");
        }
        return currentMin.getData();
    }
}
KM Fazle Azim Babu
la source
0

Voici mon code qui fonctionne avec O (1). Ici, j'ai utilisé une paire de vecteurs qui contient la valeur qui a poussé et contient également la valeur minimale jusqu'à cette valeur poussée.


Voici ma version de l'implémentation C ++.

vector<pair<int,int> >A;
int sz=0; // to keep track of the size of vector

class MinStack
{
public:
    MinStack()
    {
        A.clear();
        sz=0;
    }

    void push(int x)
    {
        int mn=(sz==0)?x: min(A[sz-1].second,x); //find the minimum value upto this pushed value
        A.push_back(make_pair(x,mn));
        sz++; // increment the size
    }

    void pop()
    {
        if(sz==0) return;
        A.pop_back(); // pop the last inserted element
        sz--;  // decrement size
    }

    int top()
    {
        if(sz==0)   return -1;  // if stack empty return -1
        return A[sz-1].first;  // return the top element
    }

    int getMin()
    {
        if(sz==0) return -1;
        return A[sz-1].second; // return the minimum value at sz-1 
    }
};
un enfant
la source
0
    **The task can be acheived by creating two stacks:**



import java.util.Stack;
    /*
     * 
     * Find min in stack using O(n) Space Complexity
     */
    public class DeleteMinFromStack {

        void createStack(Stack<Integer> primary, Stack<Integer> minStack, int[] arr) {
    /* Create main Stack and in parallel create the stack which contains the minimum seen so far while creating main Stack */
            primary.push(arr[0]);
            minStack.push(arr[0]);

            for (int i = 1; i < arr.length; i++) {
                primary.push(arr[i]);
                if (arr[i] <= minStack.peek())// Condition to check to push the value in minimum stack only when this urrent value is less than value seen at top of this stack */
                    minStack.push(arr[i]);
            }

        }

        int findMin(Stack<Integer> secStack) {
            return secStack.peek();
        }

        public static void main(String args[]) {

            Stack<Integer> primaryStack = new Stack<Integer>();
            Stack<Integer> minStack = new Stack<Integer>();

            DeleteMinFromStack deleteMinFromStack = new DeleteMinFromStack();

            int[] arr = { 5, 5, 6, 8, 13, 1, 11, 6, 12 };
            deleteMinFromStack.createStack(primaryStack, minStack, arr);
            int mimElement = deleteMinFromStack.findMin(primaryStack, minStack);
    /** This check for algorithm when the main Stack Shrinks by size say i as in loop below */
            for (int i = 0; i < 2; i++) {
                primaryStack.pop();
            }

            System.out.println(" Minimum element is " + mimElement);
        }

    }
/*
here in have tried to add for loop wherin the main tack can be shrinked/expaned so we can check the algorithm */
Akhil Gupta
la source
Qu'est-ce que cela ajoute, disons, la réponse de Jon Skeet ? Combien d'espace cela utilise-t-il pour n vers l'infini (voir question ou réponse liée)? Avec un langage de programmation prétendant prendre en charge OO, il semble plus approprié de créer un type de données (pas si abstrait) / (générique) Class- MinStack? La documentation Java d'Oracle conseille d'utiliser Deque.
greybeard
(Merci d'avoir pris des indices. (Les commentaires du code doivent expliquer le pourquoi, le comment et le pourquoi - mentionner qu'une condition est une condition n'est pas utile. La première ou les deux premières lignes mieux ne pas être indentées, c'est réalisé, courant, dans lequel , rétréci et élargi …))
greybeard
0

Une implémentation pratique pour trouver le minimum dans une pile d'objets conçus par l'utilisateur, nommée: École

La pile va stocker les écoles dans la pile en fonction du rang attribué à une école dans une région spécifique, par exemple, findMin () donne l'école où nous obtenons le nombre maximal de demandes d'admission, qui à son tour doit être défini par le comparateur qui utilise le rang associé aux écoles de la saison précédente.

The Code for same is below:


   package com.practical;

import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;

public class CognitaStack {

    public School findMin(Stack<School> stack, Stack<School> minStack) {

        if (!stack.empty() && !minStack.isEmpty())
            return (School) minStack.peek();
        return null;
    }

    public School removeSchool(Stack<School> stack, Stack<School> minStack) {

        if (stack.isEmpty())
            return null;
        School temp = stack.peek();
        if (temp != null) {
            // if(temp.compare(stack.peek(), minStack.peek())<0){
            stack.pop();
            minStack.pop();
            // }

            // stack.pop();
        }
        return stack.peek();
    }

    public static void main(String args[]) {

        Stack<School> stack = new Stack<School>();
        Stack<School> minStack = new Stack<School>();

        List<School> lst = new LinkedList<School>();

        School s1 = new School("Polam School", "London", 3);
        School s2 = new School("AKELEY WOOD SENIOR SCHOOL", "BUCKINGHAM", 4);
        School s3 = new School("QUINTON HOUSE SCHOOL", "NORTHAMPTON", 2);
        School s4 = new School("OAKLEIGH HOUSE SCHOOL", " SWANSEA", 5);
        School s5 = new School("OAKLEIGH-OAK HIGH SCHOOL", "Devon", 1);
        School s6 = new School("BritishInter2", "Devon", 7);

        lst.add(s1);
        lst.add(s2);
        lst.add(s3);
        lst.add(s4);
        lst.add(s5);
        lst.add(s6);

        Iterator<School> itr = lst.iterator();
        while (itr.hasNext()) {
            School temp = itr.next();
            if ((minStack.isEmpty()) || (temp.compare(temp, minStack.peek()) < 0)) { // minStack.peek().equals(temp)
                stack.push(temp);
                minStack.push(temp);
            } else {
                minStack.push(minStack.peek());
                stack.push(temp);
            }

        }

        CognitaStack cogStack = new CognitaStack();
        System.out.println(" Minimum in Stack is " + cogStack.findMin(stack, minStack).name);
        cogStack.removeSchool(stack, minStack);
        cogStack.removeSchool(stack, minStack);

        System.out.println(" Minimum in Stack is "
                + ((cogStack.findMin(stack, minStack) != null) ? cogStack.findMin(stack, minStack).name : "Empty"));
    }

}

L'objet école est également le suivant:

package com.practical;

import java.util.Comparator;

public class School implements Comparator<School> {

    String name;
    String location;
    int rank;

    public School(String name, String location, int rank) {
        super();
        this.name = name;
        this.location = location;
        this.rank = rank;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((location == null) ? 0 : location.hashCode());
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + rank;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        School other = (School) obj;
        if (location == null) {
            if (other.location != null)
                return false;
        } else if (!location.equals(other.location))
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (rank != other.rank)
            return false;
        return true;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    public int compare(School o1, School o2) {
        // TODO Auto-generated method stub
        return o1.rank - o2.rank;
    }

}

class SchoolComparator implements Comparator<School> {

    public int compare(School o1, School o2) {
        return o1.rank - o2.rank;
    }

}

Cet exemple couvre les éléments suivants: 1. Implémentation de la pile pour les objets définis par l'utilisateur, ici, école 2. Implémentation de la méthode hashcode () et equals () en utilisant tous les champs d'objets à comparer 3. Une implémentation pratique pour le scénario où nous rqeuire pour que l'opération Stack contains soit dans l'ordre O (1)

Akhil Gupta
la source
Il n'y a pas de balise de langue à cette question (bien au contraire:): language-agnosticveuillez spécifier ce que vous utilisez pour le code (et supprimez les espaces avant The Code for same is below:.) Comment cela prend-il en charge stack.pop()? (et push()?)
greybeard
0

Voici l'implémentation PHP de ce qui a été expliqué dans la réponse de Jon Skeet comme l'implémentation légèrement meilleure de la complexité de l'espace pour obtenir le maximum de pile dans O (1).

<?php

/**
 * An ordinary stack implementation.
 *
 * In real life we could just extend the built-in "SplStack" class.
 */
class BaseIntegerStack
{
    /**
     * Stack main storage.
     *
     * @var array
     */
    private $storage = [];

    // ------------------------------------------------------------------------
    // Public API
    // ------------------------------------------------------------------------

    /**
     * Pushes to stack.
     *
     * @param  int $value New item.
     *
     * @return bool
     */
    public function push($value)
    {
        return is_integer($value)
            ? (bool) array_push($this->storage, $value)
            : false;
    }

    /**
     * Pops an element off the stack.
     *
     * @return int
     */
    public function pop()
    {
        return array_pop($this->storage);
    }

    /**
     * See what's on top of the stack.
     *
     * @return int|bool
     */
    public function top()
    {
        return empty($this->storage)
            ? false
            : end($this->storage);
    }

    // ------------------------------------------------------------------------
    // Magic methods
    // ------------------------------------------------------------------------

    /**
     * String representation of the stack.
     *
     * @return string
     */
    public function __toString()
    {
        return implode('|', $this->storage);
    }
} // End of BaseIntegerStack class

/**
 * The stack implementation with getMax() method in O(1).
 */
class Stack extends BaseIntegerStack
{
    /**
     * Internal stack to keep track of main stack max values.
     *
     * @var BaseIntegerStack
     */
    private $maxStack;

    /**
     * Stack class constructor.
     *
     * Dependencies are injected.
     *
     * @param BaseIntegerStack $stack Internal stack.
     *
     * @return void
     */
    public function __construct(BaseIntegerStack $stack)
    {
        $this->maxStack = $stack;
    }

    // ------------------------------------------------------------------------
    // Public API
    // ------------------------------------------------------------------------

    /**
     * Prepends an item into the stack maintaining max values.
     *
     * @param  int $value New item to push to the stack.
     *
     * @return bool
     */
    public function push($value)
    {
        if ($this->isNewMax($value)) {
            $this->maxStack->push($value);
        }

        parent::push($value);
    }

    /**
     * Pops an element off the stack maintaining max values.
     *
     * @return int
     */
    public function pop()
    {
        $popped = parent::pop();

        if ($popped == $this->maxStack->top()) {
            $this->maxStack->pop();
        }

        return $popped;
    }

    /**
     * Finds the maximum of stack in O(1).
     *
     * @return int
     * @see push()
     */
    public function getMax()
    {
        return $this->maxStack->top();
    }

    // ------------------------------------------------------------------------
    // Internal helpers
    // ------------------------------------------------------------------------

    /**
     * Checks that passing value is a new stack max or not.
     *
     * @param  int $new New integer to check.
     *
     * @return boolean
     */
    private function isNewMax($new)
    {
        return empty($this->maxStack) OR $new > $this->maxStack->top();
    }

} // End of Stack class

// ------------------------------------------------------------------------
// Stack Consumption and Test
// ------------------------------------------------------------------------
$stack = new Stack(
    new BaseIntegerStack
);

$stack->push(9);
$stack->push(4);
$stack->push(237);
$stack->push(5);
$stack->push(556);
$stack->push(15);

print "Stack: $stack\n";
print "Max: {$stack->getMax()}\n\n";

print "Pop: {$stack->pop()}\n";
print "Pop: {$stack->pop()}\n\n";

print "Stack: $stack\n";
print "Max: {$stack->getMax()}\n\n";

print "Pop: {$stack->pop()}\n";
print "Pop: {$stack->pop()}\n\n";

print "Stack: $stack\n";
print "Max: {$stack->getMax()}\n";

// Here's the sample output:
//
// Stack: 9|4|237|5|556|15
// Max: 556
//
// Pop: 15
// Pop: 556
//
// Stack: 9|4|237|5
// Max: 237
//
// Pop: 5
// Pop: 237
//
// Stack: 9|4
// Max: 9
sepehr
la source
0

Voici l'implémentation C ++ de Jon Skeets Answer . Ce n'est peut-être pas le moyen le plus optimal de le mettre en œuvre, mais il fait exactement ce qu'il est censé faire.

class Stack {
private:
    struct stack_node {
        int val;
        stack_node *next;
    };
    stack_node *top;
    stack_node *min_top;
public:
    Stack() {
        top = nullptr;
        min_top = nullptr;
    }    
    void push(int num) {
        stack_node *new_node = nullptr;
        new_node = new stack_node;
        new_node->val = num;

        if (is_empty()) {
            top = new_node;
            new_node->next = nullptr;

            min_top = new_node;
            new_node->next = nullptr;
        } else {
            new_node->next = top;
            top = new_node;

            if (new_node->val <= min_top->val) {
                new_node->next = min_top;
                min_top = new_node;
            }
        }
    }

    void pop(int &num) {
        stack_node *tmp_node = nullptr;
        stack_node *min_tmp = nullptr;

        if (is_empty()) {
            std::cout << "It's empty\n";
        } else {
            num = top->val;
            if (top->val == min_top->val) {
                min_tmp = min_top->next;
                delete min_top;
                min_top = min_tmp;
            }
            tmp_node = top->next;
            delete top;
            top = tmp_node;
        }
    }

    bool is_empty() const {
        return !top;
    }

    void get_min(int &item) {
        item = min_top->val;
    }
};

Et voici le pilote de la classe

int main() {
    int pop, min_el;
    Stack my_stack;

    my_stack.push(4);
    my_stack.push(6);
    my_stack.push(88);
    my_stack.push(1);
    my_stack.push(234);
    my_stack.push(2);

    my_stack.get_min(min_el);
    cout << "Min: " << min_el << endl;

    my_stack.pop(pop);
    cout << "Popped stock element: " << pop << endl;

    my_stack.pop(pop);
    cout << "Popped stock element: " << pop << endl;

    my_stack.pop(pop);
    cout << "Popped stock element: " << pop << endl;

    my_stack.get_min(min_el);
    cout << "Min: " << min_el << endl;

    return 0;
}

Production:

Min: 1
Popped stock element: 2
Popped stock element: 234
Popped stock element: 1
Min: 4
NikaTsanka
la source
0

Nous pouvons le faire en temps O (n) et en complexité spatiale O (1), comme ceci:

class MinStackOptimized:
  def __init__(self):
      self.stack = []
      self.min = None

  def push(self, x): 
      if not self.stack:
          # stack is empty therefore directly add
          self.stack.append(x)
          self.min = x 
      else:
          """
          Directly add (x-self.min) to the stack. This also ensures anytime we have a 
          negative number on the stack is when x was less than existing minimum
          recorded thus far.
          """
          self.stack.append(x-self.min)
          if x < self.min:
              # Update x to new min
              self.min = x 

  def pop(self):
      x = self.stack.pop()
      if x < 0:
          """ 
          if popped element was negative therefore this was the minimum
          element, whose actual value is in self.min but stored value is what
          contributes to get the next min. (this is one of the trick we use to ensure
          we are able to get old minimum once current minimum gets popped proof is given
          below in pop method), value stored during push was:
          (x - self.old_min) and self.min = x therefore we need to backtrack
          these steps self.min(current) - stack_value(x) actually implies to
              x (self.min) - (x - self.old_min)
          which therefore gives old_min back and therefore can now be set
          back as current self.min.
          """
          self.min = self.min - x 

  def top(self):
      x = self.stack[-1]
      if x < 0:
          """ 
          As discussed above anytime there is a negative value on stack, this
          is the min value so far and therefore actual value is in self.min,
          current stack value is just for getting the next min at the time
          this gets popped.
          """
          return self.min
      else:
          """ 
          if top element of the stack was positive then it's simple, it was
          not the minimum at the time of pushing it and therefore what we did
          was x(actual) - self.min(min element at current stage) let's say `y`
          therefore we just need to reverse the process to get the actual
          value. Therefore self.min + y, which would translate to
              self.min + x(actual) - self.min, thereby giving x(actual) back
          as desired.
          """
          return x + self.min

  def getMin(self):
      # Always self.min variable holds the minimum so for so easy peezy.
      return self.min
AnukuL
la source
0

Je pense que vous pouvez simplement utiliser une LinkedList dans votre implémentation de pile.

La première fois que vous transmettez une valeur, vous mettez cette valeur en tête de liste liée.

puis chaque fois que vous poussez une valeur, si la nouvelle valeur <head.data, effectuez une opération prepand (ce qui signifie que la tête devient la nouvelle valeur)

sinon, effectuez une opération d'ajout.

Quand vous faites un pop (), vous vérifiez si min == linkedlist.head.data, si oui, alors head = head.next;

Voici mon code.

public class Stack {

int[] elements;
int top;
Linkedlists min;

public Stack(int n) {
    elements = new int[n];
    top = 0;
    min = new Linkedlists();
}

public void realloc(int n) {
    int[] tab = new int[n];
    for (int i = 0; i < top; i++) {
        tab[i] = elements[i];
    }

    elements = tab;
}

public void push(int x) {
    if (top == elements.length) {
        realloc(elements.length * 2);
    }
    if (top == 0) {
        min.pre(x);
    } else if (x < min.head.data) {
        min.pre(x);
    } else {
        min.app(x);
    }
    elements[top++] = x;
}

public int pop() {

    int x = elements[--top];
    if (top == 0) {

    }
    if (this.getMin() == x) {
        min.head = min.head.next;
    }
    elements[top] = 0;
    if (4 * top < elements.length) {
        realloc((elements.length + 1) / 2);
    }

    return x;
}

public void display() {
    for (Object x : elements) {
        System.out.print(x + " ");
    }

}

public int getMin() {
    if (top == 0) {
        return 0;
    }
    return this.min.head.data;
}

public static void main(String[] args) {
    Stack stack = new Stack(4);
    stack.push(2);
    stack.push(3);
    stack.push(1);
    stack.push(4);
    stack.push(5);
    stack.pop();
    stack.pop();
    stack.pop();
    stack.push(1);
    stack.pop();
    stack.pop();
    stack.pop();
    stack.push(2);
    System.out.println(stack.getMin());
    stack.display();

}

 }
Zok
la source
Ayez une séquence de nombres. Dans une boucle, si le nombre est pair, faites apparaître deux éléments. Appuyez sur le nombre et imprimez le minimum.
greybeard
? Je ne comprends pas votre commentaire
Zok
Nous pouvons ajuster la méthode pop () pour vérifier si la valeur supérieure == 0, si c'est le cas, nous effaçons la liste chaînée en faisant min.head = null, min.head.next = null
Zok
0
public class MinStack<E>{

    private final LinkedList<E> mainStack = new LinkedList<E>();
    private final LinkedList<E> minStack = new LinkedList<E>();
    private final Comparator<E> comparator;

    public MinStack(Comparator<E> comparator) 
    {
        this.comparator = comparator;
    }

    /**
     * Pushes an element onto the stack.
     *
     *
     * @param e the element to push
     */
    public void push(E e) {
        mainStack.push(e);
        if(minStack.isEmpty())
        {
            minStack.push(e);
        }
        else if(comparator.compare(e, minStack.peek())<=0)
        {
            minStack.push(e);
        }
        else
        {
            minStack.push(minStack.peek());
        }
    }

    /**
     * Pops an element from the stack.
     *
     *
     * @throws NoSuchElementException if this stack is empty
     */
    public E pop() {
       minStack.pop();
       return  mainStack.pop();
    }

    /**
     * Returns but not remove smallest element from the stack. Return null if stack is empty.
     *
     */
    public E getMinimum()
    {
        return minStack.peek();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Main stack{");
        for (E e : mainStack) {         
            sb.append(e.toString()).append(",");
        }
        sb.append("}");

        sb.append(" Min stack{");
        for (E e : minStack) {          
            sb.append(e.toString()).append(",");
        }
        sb.append("}");

        sb.append(" Minimum = ").append(getMinimum());
        return sb.toString();
    }

    public static void main(String[] args) {
        MinStack<Integer> st = new MinStack<Integer>(Comparators.INTEGERS);

        st.push(2);
        Assert.assertTrue("2 is min in stack {2}", st.getMinimum().equals(2));
        System.out.println(st);

        st.push(6);
        Assert.assertTrue("2 is min in stack {2,6}", st.getMinimum().equals(2));
        System.out.println(st);

        st.push(4);
        Assert.assertTrue("2 is min in stack {2,6,4}", st.getMinimum().equals(2));
        System.out.println(st);

        st.push(1);
        Assert.assertTrue("1 is min in stack {2,6,4,1}", st.getMinimum().equals(1));
        System.out.println(st);

        st.push(5);
        Assert.assertTrue("1 is min in stack {2,6,4,1,5}", st.getMinimum().equals(1));
        System.out.println(st);

        st.pop();
        Assert.assertTrue("1 is min in stack {2,6,4,1}", st.getMinimum().equals(1));
        System.out.println(st);

        st.pop();
        Assert.assertTrue("2 is min in stack {2,6,4}", st.getMinimum().equals(2));
        System.out.println(st);

        st.pop();
        Assert.assertTrue("2 is min in stack {2,6}", st.getMinimum().equals(2));
        System.out.println(st);

        st.pop();
        Assert.assertTrue("2 is min in stack {2}", st.getMinimum().equals(2));
        System.out.println(st);

        st.pop();
        Assert.assertTrue("null is min in stack {}", st.getMinimum()==null);
        System.out.println(st);
    }
}
Nitin Taur
la source
0
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace Solution 
{
    public class MinStack
    {
        public MinStack()
        {
            MainStack=new Stack<int>();
            Min=new Stack<int>();
        }

        static Stack<int> MainStack;
        static Stack<int> Min;

        public void Push(int item)
        {
            MainStack.Push(item);

            if(Min.Count==0 || item<Min.Peek())
                Min.Push(item);
        }

        public void Pop()
        {
            if(Min.Peek()==MainStack.Peek())
                Min.Pop();
            MainStack.Pop();
        }
        public int Peek()
        {
            return MainStack.Peek();
        }

        public int GetMin()
        {
            if(Min.Count==0)
                throw new System.InvalidOperationException("Stack Empty"); 
            return Min.Peek();
        }
    }
}
Jagadeesh Bandlamudi
la source
0

J'ai vu une solution brillante ici: https://www.geeksforgeeks.org/design-a-stack-that-supports-getmin-in-o1-time-and-o1-extra-space/

Ci-dessous est le code python que j'ai écrit en suivant l'algorithme:

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class MinStack:
    def __init__(self):
        self.head = None
        self.min = float('inf')

    # @param x, an integer
    def push(self, x):
        if self.head == None:
            self.head = Node(x)
            self.min = x
        else:
            if x >= self.min:
                n = Node(x)
                n.next = self.head
                self.head = n
            else:
                v = 2 * x - self.min
                n = Node(v)
                n.next = self.head
                self.head = n
                self.min = x

    # @return nothing
    def pop(self):
        if self.head:
            if self.head.value < self.min:
                self.min = self.min * 2 - self.head.value
            self.head = self.head.next

    # @return an integer
    def top(self):
        if self.head:
            if self.head.value < self.min:
                self.min = self.min * 2 - self.head.value
                return self.min
            else:
                return self.head.value
        else:
            return -1

    # @return an integer
    def getMin(self):
        if self.head:
            return self.min
        else:
            return -1
ibic
la source
0

Pour obtenir des éléments Min de Stack. Nous devons utiliser Two stack .ie Stack s1 et Stack s2.

  1. Au départ, les deux piles sont vides, alors ajoutez des éléments aux deux piles

--------------------- Appel récursif des étapes 2 à 4 -----------------------

  1. if Nouvel élément ajouté à la pile s1.Ensuite, pop éléments de la pile s2

  2. comparer les nouveaux éléments avec s2. lequel est le plus petit, appuyez sur s2.

  3. pop de la pile s2 (qui contient l'élément min)

Le code ressemble à:

package Stack;
import java.util.Stack;
public class  getMin 
{  

        Stack<Integer> s1= new Stack<Integer>();
        Stack<Integer> s2 = new Stack<Integer>();

        void push(int x)
        {
            if(s1.isEmpty() || s2.isEmpty())

            {
                 s1.push(x);
                 s2.push(x);
            }
            else
            {

               s1. push(x);
                int y = (Integer) s2.pop();
                s2.push(y);
                if(x < y)
                    s2.push(x);
                        }
        }
        public Integer pop()
        {
            int x;
            x=(Integer) s1.pop();
            s2.pop();
            return x;

        }
    public  int getmin()
        {
            int x1;
            x1= (Integer)s2.pop();
            s2.push(x1);
            return x1;
        }

    public static void main(String[] args) {
        getMin s = new getMin();
            s.push(10);
            s.push(20);
            s.push(30);
            System.out.println(s.getmin());
            s.push(1);
            System.out.println(s.getmin());
        }

}
RAJNISH YADAV
la source
-1

Je pense que seule l'opération push souffre, c'est assez. Mon implémentation comprend une pile de nœuds. Chaque nœud contient l'élément de données et aussi le minimum à ce moment. Ce minimum est mis à jour à chaque fois qu'une opération push est effectuée.

Voici quelques points pour comprendre:

  • J'ai implémenté la pile en utilisant la liste liée.

  • Un pointeur en haut pointe toujours vers le dernier élément poussé. Lorsqu'il n'y a aucun élément dans cette pile, le haut de la pile est NULL.

  • Lorsqu'un élément est poussé, un nouveau nœud est alloué qui a un pointeur suivant qui pointe vers la pile précédente et top est mis à jour pour pointer vers ce nouveau nœud.

La seule différence avec l'implémentation normale de la pile est que pendant l'envoi, il met à jour un membre min pour le nouveau nœud.

Veuillez jeter un œil au code implémenté en C ++ à des fins de démonstration.

/*
 *  Implementation of Stack that can give minimum in O(1) time all the time
 *  This solution uses same data structure for minimum variable, it could be implemented using pointers but that will be more space consuming
 */

#include <iostream>
using namespace std;

typedef struct stackLLNodeType stackLLNode;

struct stackLLNodeType {
    int item;
    int min;
    stackLLNode *next;
};

class DynamicStack {
private:
    int stackSize;
    stackLLNode *top;

public:
    DynamicStack();
    ~DynamicStack();
    void push(int x);
    int pop();
    int getMin();
    int size() { return stackSize; }
};

void pushOperation(DynamicStack& p_stackObj, int item);
void popOperation(DynamicStack& p_stackObj);

int main () {
    DynamicStack stackObj;

    pushOperation(stackObj, 3);
    pushOperation(stackObj, 1);
    pushOperation(stackObj, 2);
    popOperation(stackObj);
    popOperation(stackObj);
    popOperation(stackObj);
    popOperation(stackObj);
    pushOperation(stackObj, 4);
    pushOperation(stackObj, 7);
    pushOperation(stackObj, 6);
    popOperation(stackObj);
    popOperation(stackObj);
    popOperation(stackObj);
    popOperation(stackObj);

    return 0;
}

DynamicStack::DynamicStack() {
    // initialization
    stackSize = 0;
    top = NULL;
}

DynamicStack::~DynamicStack() {
    stackLLNode* tmp;
    // chain memory deallocation to avoid memory leak
    while (top) {
        tmp = top;
        top = top->next;
        delete tmp;
    }
}

void DynamicStack::push(int x) {
    // allocate memory for new node assign to top
    if (top==NULL) {
        top = new stackLLNode;
        top->item = x;
        top->next = NULL;
        top->min = top->item;
    }
    else {
        // allocation of memory
        stackLLNode *tmp = new stackLLNode;
        // assign the new item
        tmp->item = x;
        tmp->next = top;

        // store the minimum so that it does not get lost after pop operation of later minimum
        if (x < top->min)
            tmp->min = x;
        else
            tmp->min = top->min;

        // update top to new node
        top = tmp;
    }
    stackSize++;
}

int DynamicStack::pop() {
    // check if stack is empty
    if (top == NULL)
        return -1;

    stackLLNode* tmp = top;
    int curItem = top->item;
    top = top->next;
    delete tmp;
    stackSize--;
    return curItem;
}

int DynamicStack::getMin() {
    if (top == NULL)
        return -1;
    return top->min;
}
void pushOperation(DynamicStack& p_stackObj, int item) {
    cout<<"Just pushed: "<<item<<endl;
    p_stackObj.push(item);
    cout<<"Current stack min: "<<p_stackObj.getMin()<<endl;
    cout<<"Current stack size: "<<p_stackObj.size()<<endl<<endl;
}

void popOperation(DynamicStack& p_stackObj) {
    int popItem = -1;
    if ((popItem = p_stackObj.pop()) == -1 )
        cout<<"Cannot pop. Stack is empty."<<endl;
    else {
        cout<<"Just popped: "<<popItem<<endl;
        if (p_stackObj.getMin() == -1)
            cout<<"No minimum. Stack is empty."<<endl;
        else
            cout<<"Current stack min: "<<p_stackObj.getMin()<<endl;
        cout<<"Current stack size: "<<p_stackObj.size()<<endl<<endl;
    }
}

Et la sortie du programme ressemble à ceci:

Just pushed: 3
Current stack min: 3
Current stack size: 1

Just pushed: 1
Current stack min: 1
Current stack size: 2

Just pushed: 2
Current stack min: 1
Current stack size: 3

Just popped: 2
Current stack min: 1
Current stack size: 2

Just popped: 1
Current stack min: 3
Current stack size: 1

Just popped: 3
No minimum. Stack is empty.
Current stack size: 0

Cannot pop. Stack is empty.
Just pushed: 4
Current stack min: 4
Current stack size: 1

Just pushed: 7
Current stack min: 4
Current stack size: 2

Just pushed: 6
Current stack min: 4
Current stack size: 3

Just popped: 6
Current stack min: 4
Current stack size: 2

Just popped: 7
Current stack min: 4
Current stack size: 1

Just popped: 4
No minimum. Stack is empty.
Current stack size: 0

Cannot pop. Stack is empty.
Atiq Rahman
la source
-1
public interface IMinStack<T extends Comparable<T>> {
  public void push(T val);
  public T pop();
  public T minValue();
  public int size();
}

import java.util.Stack;

public class MinStack<T extends Comparable<T>> implements IMinStack<T> {
  private Stack<T> stack = new Stack<T>();
  private Stack<T> minStack = new Stack<T>();

  @Override
  public void push(T val) {
    stack.push(val);
    if (minStack.isEmpty() || val.compareTo(minStack.peek()) < 0)
        minStack.push(val);
  }

  @Override
  public T pop() {
    T val = stack.pop();
    if ((false == minStack.isEmpty())
            && val.compareTo(minStack.peek()) == 0)
        minStack.pop();
    return val;
  }

  @Override
  public T minValue() {
    return minStack.peek();
  }

  @Override
  public int size() {
    return stack.size();
  }
}
user3798488
la source