CareerCup

take two stacks.in one stack put the value a/c to requirement,consecuitevily maintain the current min value in 2nd stack.
if u do the pop operation then compare it with 2nd stack top value if equal then also pop the top of 2nd stack .

organize the stack in such a way that when you are inserting a value , pop the stack , compare , push the greater one , then push the smaller one.

now , the smallest one will always be a push away.

the stack will no more be a stack

pop the elements and save them in a BST

i took back what i said
declare another stack and keep a variable that stores the current min value

how all these solution are O(1)? you have to at least pop n elements from the stack, so it becoms order n isn't it?

node with two address part one for next node and one for contain address of next min which min to that node value .

Main two stack, with one stack having current min value

If it's any regular stack->impossible. If it's "my" stack, just make sure the min element is always on top.

Just keep a min variable .. which always checks before pushing in an element and return that element.

If the question meant to say O(n) this is how I would do it:

assuming that we could check if stack is empty
pseudo code without any error checking

find_min(stack)
    n = stack.pop()
    m = stack.pop()
    s = smaller of n and m
    if stack is empty
        return s
    else
        stack.push(s)
        find_min(stack)

T's solution would work. Another approach if we were to avoid pointers is to store min value along with the element value in each stack element.

class Stack{
int top;
int[] stack;
MinimumStack miniStack;
// constructor for stack
Stack(int capacity){
top=0;
stack=new int[capacity];
miniStack = new MinimumStack(capacity);
}
boolean isFull(){
return(top==stack.length);
}
public void push(int val){
if(!isFull()){
stack[top++]=val;
miniStack.push(val);
}else{
System.out.println("The stack is full");
}
}

public Object pop(){
if(top!=0){
miniStack.pop(stack[top-1]);
return stack[top--];
}else{
return null;
}
}

public void displayStack(){
for(int i=0;i<top;i++){
System.out.println(stack[i]);
}
}

public void displayMinimum(){
System.out.println("The current minimum is"+miniStack.getMinimum());
}

}
class MinimumStack{
int topMin;
int[] Ministack;
public MinimumStack(int capacity) {
// TODO Auto-generated constructor stub
topMin=0;
Ministack=new int[capacity];
}
public int getMinimum() {
// TODO Auto-generated method stub
if(topMin!=0){
return Ministack[topMin-1];
}
return (Integer)null;
}
boolean isMinStackFull(){
return(topMin==Ministack.length);
}

public void push(int val){
if(!isMinStackFull()){
if(topMin!=0){
if(val<Ministack[topMin-1])
Ministack[topMin++]=val;
}
else{
if(topMin==0)
Ministack[topMin++]=val;
}

}else{
System.out.println("The stack is full");
}
}
public void pop(int val){
if(Ministack[topMin]==val){
int Minval=Ministack[topMin--];
}
}


}

assholes..u guys take salary from company , do not work and then look for other jobs by doing all these bull shits...its all non sense..assholess