栈

1.栈的基本概念

栈（英语：stack）又称为堆栈或堆叠，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。

　　栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。

　　由于堆叠数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。栈也称为后进先出表。

　　这里以羽毛球筒为例，羽毛球筒就是一个栈，刚开始羽毛球筒是空的，也就是空栈，然后我们一个一个放入羽毛球，也就是一个一个push进栈，当我们需要使用羽毛球的时候，从筒里面拿，也就是pop出栈，但是第一个拿到的羽毛球是我们最后放进去的。

 java模拟简单的顺序栈实现

代码如下：

package array;

public class MyStack {
    private int maxSize; //栈的最大容量
    private int top;      //栈顶元素
    private int[] array;  //定义一个数组

    public MyStack(int size) {
        this.maxSize = size;   //自定义最大容量
        array = new int[size];
        top = -1;  //数组第一个元素下标为零
    }

    //压入数据
    public void push(int value) {
        if (top < maxSize - 1) {
            array[++top] = value;   //++top先自增后参与运算
        }
    }

    //弹出栈顶数据
    public int pop() {
        return array[top--];  //弹出栈顶元素再自减一
    }

    //访问栈顶数据
    public int peek() {
        return array[top];
    }

    //判断栈是否为空
    public boolean isEmpt() {
        return (top == -1);
    }

    //判断栈是否满了
    public boolean isFull() {
        return (top == maxSize - 1);
    }

}

 

Test：

package array;

public class MyStackTest {
    public static void main(String[] args) {
        MyStack stack = new MyStack(9);
        stack.push(5);
        stack.push(4);
        stack.push(6);
        stack.push(3);
        stack.push(2);
        stack.push(7);
        stack.push(9);
        stack.push(8);
        stack.push(1);
        System.out.println("栈顶元素为："+stack.peek());
        System.out.print("由顶至下：");
        while (!stack.isEmpt()){
            System.out.print(stack.pop()+" ");
        }
    }
}

 

 

增强功能版栈

第一个能自动扩容，第二个能存储各种不同类型的数据

import java.util.Arrays;

public class ArrayStack {
    private int maxSize;  //最大容量
    private int top;      //栈顶元素
    private Object[] allData;  //类型为Object，可以装任意类型数据

    public ArrayStack() {  //默认构造器
        this.maxSize=10;
        this.top=-1;
        this.allData=new Object[maxSize];
    }

    public ArrayStack(int size) {  //自定义初始化最大容量
        if (size<0){
            throw new IllegalArgumentException("栈初始容量不能小于0：--"+size);
        }
        this.maxSize=size;
        this.top=-1;
        this.allData=new Object[size];
    }

    //压入元素
    public Object push(Object item){
        isGrow(top+1);  //判断是否需要扩容
        allData[++top]=item;
        return item;
    }

    //弹出栈顶元素
    public Object pop(){
        Object obj=peek(); //获取栈顶元素，之后再移除
        remove(top);
        return obj;
    }

    //获取栈顶元素
    public Object peek(){
        return allData[top];
    }

    //判断栈是否为空
    public boolean isEmpt(){
        return (top==-1);
    }

    //删除栈顶元素
    public void remove(int top){
        allData[top]=null;  //置栈顶元素为空
        this.top--;
    }

    //是否需要扩容
    public boolean isGrow(int fullSize){
        int oldSize=maxSize;
        if (fullSize>=oldSize){  //判断会不会超出最大容量
            int newSize=0;
            newSize=(oldSize<<1); //左移一位，容量翻倍
            this.maxSize=newSize;60             allData= Arrays.copyOf(allData,maxSize);
            return true;
        }else {
            return false;
        }

    }

   } 

Test：

public class ArrayStackTest {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack(3);
        stack.push("success!");
        stack.push(233);
        stack.push("world!");
        stack.push("hello ");
        System.out.println(stack.peek());//获取栈顶元素
        System.out.print(stack.pop());
        System.out.print(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.peek());//现在只剩下一个元素
    }
}