数据结构之栈（基础实现）

栈

栈是先进后出（FILO)的一种数据结构，跟队列相反
（1) 栈的英文为(stack)
（2) 栈是一个先入后出(FILO-FirstInLastOut)的有序列表。
(3) 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的 一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
(4)根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 5) 图解方式说明出栈(pop)和入栈(push)的概念

标题栈的应用场景

(1) 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
(2) 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆
栈中。
(3) 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
(4) 二叉树的遍历。
(5) 图形的深度优先(depth 一 first)搜索法。

1.数组实现栈

定义一个数组模拟栈。maxsize表示最大的容量
top指针指向stack的顶部
实现的具体代码

public class Arraystack {

    //栈的大小
    private int maxsize;
    //模拟栈的数组
    private int [] arr;
    //指向栈底的指针
    private int top=-1;

    //初始化
    public Arraystack(int maxsize)
    {
        this.maxsize=maxsize;
        arr=new int[this.maxsize];
    }

    //判断栈是否满
    public boolean isfull()
    {
        return top==maxsize-1;
    }

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

    //入栈
    public void push(int a)
    {
        if (isfull())
        {
            throw new RuntimeException("栈已经满");
        }
        top++;
        arr[top]=a;
    }

    //出栈
    public int pop()
    {
        if (isEmpty())
        {
            throw new RuntimeException("栈位空");
        }
        int value=arr[top];
        top--;
        return  value;
    }

    @Override
    public String toString() {
        return "Arraystack{" +
                "maxsize=" + maxsize +
                ", arr=" + Arrays.toString(arr) +
                ", top=" + top +
                '}';
    }
}

2.用链表实现栈

public class Liststack<T> {
    //栈的长度
    private int N=0;
    //定义头指针
    private Node head;
    //获取头指针
    public Node getHead() {
        return head;
    }

    public Liststack()
    {
        head=new Node(null,null);
    }
    //获取长度
    public int length()
    {
        return N;
    }

    //判断是否为空
    public boolean isempty()
    {
        return N==0;
    }
    //入栈
    public void push(T data)
    {
        Node node=new Node(data,null);
        head.next=node;

        N++;
    }
    //出栈
    public T pop()
    {
        Node temp=head.next;
        T vaule=(T)temp.data;
        if (temp==null)
        {
            return null;
        }
        head.next=head.next.next;

            N--;

        return vaule;
    }
    //结点类
    private class  Node<T>{
        public T data;
        public Node next;

        public Node(T data,Node next)
        {
            this.data= data;
            this.next=next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "data=" + data +
                    ", next=" + next +
                    '}';
        }
    }

}