getMinimum（）がO(1)になるようにスタックを設計します
これはインタビューの質問の1つです。 getMinimum（）関数がスタック内の最小要素を返すように、整数値を保持するスタックを設計する必要があります。
たとえば、次の例を考えてください
ケース＃1 5-> TOP 1 4 6 2 getMinimum（）が呼び出されると、スタック内の最小要素 である1を返します。 ケース＃2 stack.pop（） stack.pop（） 注： 5と1の両方がスタックからポップされます。この後、スタックは のようになります。 4-> TOP 6 2 getMinimum（）が呼び出されると、 stack。 の最小値である2が返されます。
制約条件：
- getMinimumはO（1）の最小値を返す必要があります
- また、設計中にスペースの制約も考慮する必要があり、余分なスペースを使用する場合は、一定のスペースにする必要があります。
編集：これは「一定のスペース」制約に失敗します-それは基本的に必要なスペースを2倍にします。 does n'tが、実行時の複雑さをどこかで壊すことなく（たとえば、プッシュ/ポップO（n）を作成することなく）、それを行う解決策があることを非常に疑います。これは、必要なスペースのcomplexityを変更しないことに注意してください。 O(n)のスペース要件を持つスタックがある場合、これはまだ異なる定数係数を持つO(n)になります。
非定数空間ソリューション
「スタック内のすべての値の最小値」の「重複」スタックを保持します。メインスタックをポップするときは、最小スタックもポップします。メインスタックをプッシュするときは、新しい要素または現在の最小のいずれか小さい方をプッシュします。 getMinimum()は、minStack.peek()として実装されます。
したがって、例を使用すると、次のようになります。
Real stack Min stack
5 --> TOP 1
1 1
4 2
6 2
2 2
2回ポップすると、以下が得られます。
Real stack Min stack
4 2
6 2
2 2
これだけでは十分でない場合はお知らせください。簡単に理解できますが、最初は少し頭を痛めるかもしれません:)
（もちろん、デメリットはスペース要件を2倍にすることです。しかし、実行時間はそれほど苦しむことはありません-つまり、同じ複雑さです。）
編集：少し厄介なバリエーションがありますが、一般的にはより良いスペースがあります。最小スタックはまだありますが、メインスタックからポップする値が最小スタックの値と等しい場合にのみ、そこからポップします。メインスタックにプッシュされる値がまたは等しい現在の最小値より小さい場合、Push最小スタックにのみ。これにより、最小値の重複が許可されます。 getMinimum()はまだ単なるピーク操作です。たとえば、元のバージョンを取得してもう一度1を押すと、次のようになります。
Real stack Min stack
1 --> TOP 1
5 1
1 2
4
6
2
上記からポップすると、1 == 1であるため、両方のスタックからポップします。
Real stack Min stack
5 --> TOP 1
1 2
4
6
2
再度ポップonly 5> 1であるため、メインスタックからポップします。
Real stack Min stack
1 1
4 2
6
2
1 == 1であるため、再びポップすると両方のスタックがポップされます。
Real stack Min stack
4 2
6
2
これは、同じ最悪の場合のスペースの複雑さ（元のスタックの2倍）になりますが、「新しい最小値または等しい値」がめったに得られない場合は、スペースの使用量がはるかに多くなります。
編集：ピートの邪悪なスキームの実装です。私はそれを徹底的にテストしていませんが、私は考えるそれは大丈夫です:)
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;
}
}
最小値を保持するフィールドを追加し、Pop（）およびPush（）中に更新します。そうすれば、getMinimum（）はO（1）になりますが、Pop（）とPush（）はもう少し作業が必要になります。
最小値がポップされる場合、Pop（）はO（n）になります。それ以外の場合は、両方ともO（1）になります。 Stackの実装に従って、Push（）のサイズを変更するとO(n)になります。
ここに簡単な実装があります
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; } }
}
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();
}
}
現在の最小値を明示的に保存し、最小値が変更される場合、値をプッシュする代わりに、新しい最小値の反対側に同じ差の値をプッシュします（min = 7で5をプッシュすると、代わりに3をプッシュします（5- | 7-5 | = 3）minを5に設定します; minが5のときに3をポップすると、ポップされた値がminより小さいことがわかるので、手順を逆にして新しいminの7を取得し、前の値を返します分）。変更を引き起こさない値が現在の最小値よりも大きいため、最小値を変更する値と変更しない値を区別するために使用できるものがあります。
固定サイズの整数を使用する言語では、値の表現から少しのスペースを借りているため、アンダーフローする可能性があり、アサートは失敗します。しかし、そうでなければ、それは一定の余分なスペースであり、すべての操作はまだO（1）です。
代わりにリンクリストに基づくスタックには、Cで次のポインターの最下位ビット、またはJavaリンクリスト内のオブジェクトのタイプなど、少し借りることができる他の場所があります。 Javaの場合、リンクごとのオブジェクトオーバーヘッドがあるため、連続したスタックと比較して使用されるスペースが増えることを意味します。
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;
}
Cでは、オーバーヘッドはありません。次のポインターのlsbを借用できます。
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.;
ただし、これらはいずれもO（1）ではありません。これらは、これらの言語の数字、オブジェクト、またはポインターの表現にある穴を利用するため、実際にはこれ以上スペースを必要としません。しかし、よりコンパクトな表現を使用した理論的なマシンでは、それぞれの表現に追加ビットを追加する必要があります。
上記のすべての制約（定数時間操作）および定数の余分なスペースを満たすソリューションを見つけました。
アイデアは、最小値と入力数の差を保存し、最小値でなくなった場合に最小値を更新することです。
コードは次のとおりです。
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;
}
}
クレジットは次のとおりです： https://leetcode.com/discuss/15679/share-my-Java-solution-with-only-one-stack
さて、Pushとpopの実行時の制約は何ですか？定数である必要がない場合は、これら2つの操作の最小値を計算します（O（n）にします）。それ以外の場合、一定の追加スペースでこれを行う方法はわかりません。
ここに完全なコードを投稿して、特定のスタックの最小値と最大値を見つけます。
時間の複雑さは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());
}
}
問題が発生した場合はお知らせください
ありがとう、Vikash
元のスタッククラスを拡張し、最小追跡を追加するだけです。元の親クラスに通常どおり他のすべてを処理させます。
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();
}
}
別の種類のスタックを使用しました。これが実装です。
//
// 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;
}
出力：
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
それを試してみてください。質問に答えていると思います。すべてのペアの2番目の要素は、その要素が挿入されたときに見られる最小値を示します。
リンクリストを使用したJavaのソリューションを次に示します。
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;
}
}
これは、O（1）で実行される私のコードです。私が投稿した以前のコードには、最小要素がポップされたときに問題がありました。コードを修正しました。これは、現在のプッシュされた要素の上のスタックに存在する最小要素を維持する別のスタックを使用します。
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);
}
}
私たちが取り組んでいるスタックはこれだと仮定しましょう：
6 , minvalue=2
2 , minvalue=2
5 , minvalue=3
3 , minvalue=3
9 , minvalue=7
7 , minvalue=7
8 , minvalue=8
上記の表現では、スタックは左の値によってのみ構築され、右の値の[最小値]は、1つの変数に格納される説明目的でのみ書き込まれます。
実際の問題は、最小値である値がその時点で削除されると、スタックを反復することなく次の最小要素が何であるかをどのように知ることができるかです。
たとえば、6 getがポップされたスタックのように、最小要素は2であるため、これは最小要素ではないことがわかります。したがって、最小値を更新せずにこれを安全に削除できます。
しかし、2をポップすると、現在最小値が2であることがわかります。このgetがポップされた場合、最小値を3に更新する必要があります。
ポイント1：
注意深く観察する場合、この特定の状態[2、minvalue = 2]からminvalue = 3を生成する必要があります。または、特定の状態[3、minvalue = 3]からminvalue = 7を生成する必要がある場合、またはスタックをさらに深くする場合、この特定の状態[7、minvalueからminvalue = 8を生成する必要があります= 7]
上記の3つのケースすべてに共通することに気付きましたか？生成する必要がある値は、両方が等しい2つの変数に依存しています。正しい。これは、現在の最小値よりも小さい要素をプッシュすると、基本的にスタック内のその要素をプッシュし、最小値の同じ数値も更新するためです。
Point2：
したがって、基本的には同じ番号の複製を1回はスタックに、1回はminvalue変数に格納します。この重複を回避することに焦点を当て、有用なデータをスタックまたは最小値に保存して、上記のケースに示すように前の最小値を生成する必要があります。
Pushに保存する値がminmumvalueより小さい場合に、スタックに何を保存するかに注目しましょう。この変数にyという名前を付けましょう。これで、スタックは次のようになります。
6 , minvalue=2
y1 , minvalue=2
5 , minvalue=3
y2 , minvalue=3
9 , minvalue=7
y3 , minvalue=7
8 , minvalue=8
すべての値が同じになるという混乱を避けるために、これらの名前をy1、y2、y3に変更しました。
Point3：
では、y1、y2、およびy3の制約を見つけてみましょう。 pop（）を実行中にminvalueを更新する必要があるのはいつか、minvalueに等しい要素をポップしたときだけ覚えていますか。最小値より大きい値をポップした場合、最小値を更新する必要はありません。したがって、minvalueの更新をトリガーするには、y1、y2＆y3が対応するminvalueよりも小さくなければなりません。[重複を避けるために等値を使用する[Point2]]ため、制約は[y <minValue]です。
ここで、yを設定するために戻って、Push時に値を生成してyを入力する必要があります。 Pushに来る値をprevMinvalueよりも小さいxにし、実際にスタックにプッシュする値をyにします。したがって、newMinValue = xおよびy <newMinvalueであることは明らかです。
次に、prevMinvalueとx（newMinvalue）を使用して、yを計算する必要があります（yはnewMinValue（x）よりも小さい任意の数になる可能性があるため、制約を満たすことができる数を見つける必要があります）。
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].
したがって、xをプッシュするときに、それがprevMinvalueより小さい場合、y [2 * x-prevMinValue]をプッシュしてnewMinValue = xを更新します。
また、ポップの時点で、スタックにminValueより小さい値が含まれている場合、それがminVAlueを更新するトリガーになります。 curMinValueとyからprevMinValueを計算する必要があります。 y = 2 * curMinValue-prevMinValue [証明済み] prevMinVAlue = 2 * curMinvalue-y。
2 * curMinValue-yは、現在prevMinValueに更新する必要がある番号です。
同じロジックのコードは、O(1)時間と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;
}
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();
}
}
O（1）のスタックの最大値を取得するためのわずかに優れたスペースの複雑さの実装として Jon Skeetの答え で説明したもののPHP実装です。
<?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
canこれをO(n)時間とO(1)スペースの複雑さで行います。
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
**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 */
スタック実装でLinkedListを単純に使用できると思います。
初めて値をプッシュするときは、この値をリンクリストのヘッドとして配置します。
次に、値をプッシュするたびに、新しい値<head.dataの場合、prepand操作を行います（つまり、ヘッドが新しい値になることを意味します）
そうでない場合は、追加操作を行います。
Pop（）を作成するときは、min == linkedlist.head.dataかどうかを確認し、yesの場合はhead = head.nextを確認します。
これが私のコードです。
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();
}
}
Jon Skeets Answer のC++実装です。それを実装するのに最適な方法ではないかもしれませんが、それはまさにそれが想定されていることを行います。
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;
}
};
そして、これがクラスのドライバーです
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;
}
出力：
Min: 1
Popped stock element: 2
Popped stock element: 234
Popped stock element: 1
Min: 4
ここで素晴らしいソリューションを見ました： https://www.geeksforgeeks.org/design-a-stack-that-supports-getmin-in-o1-time-and-o1-extra-space/
以下は、アルゴリズムに従って作成したpythonコードです。
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
私はこの解決策を見つけました ここ
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;
};
これは、O（1）で実行される私のコードです。ここでは、プッシュされた値と、このプッシュされた値までの最小値を含むベクトルペアを使用しました。
これが私のバージョンの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
}
};
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);
}
}
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);
}
}
以下の名前のユーザー設計オブジェクトのスタックで最小値を見つけるための実用的な実装：School
スタックは、特定の地域の学校に割り当てられたランクに基づいてスタックに学校を保存します。たとえば、findMin（）は、入学申請の最大数を取得する学校を提供します。前のシーズンの学校に関連するランクを使用する比較器。
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"));
}
}
また、学校オブジェクトは次のとおりです。
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;
}
}
この例では、次の内容を取り上げます。1.ユーザー定義オブジェクトのスタックの実装、ここ、学校2.比較するオブジェクトのすべてのフィールドを使用するhashcode（）およびequals（）メソッドの実装3.シナリオの実用的な実装スタックを取得するrqeuireには、O（1）の順序になる操作が含まれます
#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);
}
}
これが私の実装バージョンです。
struct MyStack {
int要素;
int * CurrentMiniAddress;
};
void Push（int value）
{
//構造を作成し、値を設定します
MyStack S = new MyStack（）;
S-> element = value;
if（Stack.Empty（））
{
//スタックは空なので、CurrentMiniAddressを自分自身にポイントします
S-> CurrentMiniAddress = S;
}
else
{
//スタックは空ではありません
//上の要素を取得します。いいえPop（）
MyStack * TopElement = Stack.Top（）;
//常にTOP要素が
を指すことを忘れない// thsの最小要素全体スタック
if（S-> element CurrentMiniAddress-> element）
{
//現在値がスタック全体の最小値である場合
//その後Sは自分自身を指します
S-> CurrentMiniAddress = S;
}
else
{
//したがって、これは全体の最小値ではありませんstack
//心配なし、TOPは最小要素を保持しています
S-> CurrentMiniAddress = TopElement-> CurrentMiniAddress;
}
}
Stack.Add（S）;
}
void Pop（）
{
if（！Stack.Empty（） ）
{
Stack.Pop（）;
}
}
int GetMinimum（Stack＆stack）
{
if（！stack.Empty（））
{
MyStack * Top = stack.top（）;
// Topは常にminimumx
return Top-> CurrentMiniAddress-> element;
}
}
Stackから要素を取得します。 2つのスタック.i.e Stack s1とStack s2を使用する必要があります。
- 最初は、両方のスタックが空なので、両方のスタックに要素を追加します
---------------------ステップ2を再帰的に呼び出す4 -----------------------
新しい要素がスタックs1に追加された場合、スタックs2から要素をポップします
新しい要素をs2と比較します。どちらが小さいか、s2にプッシュします。
スタックs2（min要素を含む）からポップします
コードは次のようになります：
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());
}
}
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();
}
}
}
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
}
}