本文已参与「新人创作礼」活动，一起开启掘金创作之路。 ​

 栈是一种特殊的线性表，这种线性表只能在固定一端进行插入、删除操作。

栈的常用操作：

初始化：通常是一个构造器，创建一个空栈；

返回栈的长度：返回栈中的元素个数；

入栈：向栈的栈顶插入一个元素，栈的长度+1；

出栈：从栈的栈顶删除一个元素，栈的长度-1，返回被删除的元素；

访问栈顶的元素：

判断栈是否为空：

清空栈：

package MyJava2;

import java.util.Arrays;

public class SequenceStack {
    private int DEFAULT_SIZE=10;
    private int capacity;
    private String[] elements;
    private int size=0;
    
    public SequenceStack(){
        capacity=DEFAULT_SIZE;
        elements=new String[capacity];
    }
    public SequenceStack(String data){
        capacity=DEFAULT_SIZE;
        elements=new String[capacity];
        elements[0]=data;
        size++;
    }
    public SequenceStack(String data,int initlize){
        capacity=1;
        while(capacity<initlize){
            capacity<<=1;
        }
        elements=new String[capacity];
        elements[0]=data;
        size++;
    }

    public void push(String data){
        ensureCapacity(size+1);
        elements[size++]=data;
    }
    private void ensureCapacity(int minCapacity) {
        while (capacity<minCapacity){
            capacity<<=1;
        }
        elements= Arrays.copyOf(elements,capacity);
    }

    public String pop(){
        String old=elements[size-1];
        elements[--size]=null;
        return old;
    }

    public String peek(){
        return elements[size-1];
    }

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

    public void clear(){
        Arrays.fill(elements,null);
    }

    public String toString(){
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<size;i++){
            sb.append(elements[i]+",");
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        SequenceStack stack=new SequenceStack();
        stack.push("A");
        stack.push("B");
        stack.push("C");
        System.out.println(stack.toString());
        System.out.println(stack.size);
        System.out.println(stack.empty());
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.peek());
    }


}

​

getMin

​

import java.util.Stack;
public class GetMinStack {
    private Stack<Integer> stackData=new Stack();
    private Stack<Integer> stackMin=new Stack();
    public void push(int newNum){
        if(stackMin.isEmpty()){//若stackMin中没有数值，则将数值压入；
            this.stackMin.push(newNum);
        }else if(newNum<=getMin()){//若新压入的数值小于得到的最小值，则再次压入stackMin的栈顶；
            this.stackMin.push(newNum);
        }
        this.stackData.push(newNum);//将所有的数值压入stackData;

    }
    public int pop(){
        if(this.stackData.isEmpty()){
            throw new RuntimeException("stack is empty!");
        }
        int value=this.stackData.pop();
        if(value==this.getMin()){//同步一下，data栈已经移走了，且是最小，那么最小栈也应该移走最小的
            this.stackMin.pop();
        }
        return value;
    }
    public int getMin() {
        if(this.stackMin.isEmpty()){
            throw new RuntimeException("stack is empty!");
        }
        return this.stackMin.peek();
    }
    public static void main(String[] args) {
        GetMinStack g=new GetMinStack();
        g.push(1);
        g.push(3);
        g.push(5);
        g.push(4);
        System.out.println(g.getMin());
    }
}

​