栈和队列及JAVA实现

一.栈（LIFO)和队列(FIFO)也是经常使用的数据结构，我们经常用到的递归，实现时就是用栈保存相关的调用函数以及变量，线程在实现时也用栈来保存一些函数调用以及变量。栈其实是一种受限制的线性表，它对存储数据的规则是只能从一端进入数据，删除数据的时候也只能删除栈顶的数据，就是大家俗知的后进先出。队列和栈的最大不同就是队列是先进先出。

二.栈和队列的性质
栈：栈是只能进行一端插入删除操作的特殊线性表，它就像一个向上开口的箱子，刚开始放入的数据会先存在栈底，那么显然，当从箱子里取东西最上面的会被最先拿走，栈也一样，从栈中删除元素就是只能从栈顶删除数据。
队列：队列也是一种特殊的线性表，只能在队列的尾部插入数据，只能在队列的头部删除数据。

三.栈的基本操作：
1.入栈push();
2.出栈pop();
3.判断栈是否为空empty(）；
4.获取栈顶元素peek();
5.访问栈中元素个数size();
(队列的基本操作和栈一样大同小异，就不列举了）

四.栈的JAVA实现

基于数组实现的栈

public class Stack<E> {
    private Object[] data = null;
    private int maxSize=0;   //栈容量
    private int top =-1;  //栈顶指针
    
    /**
     * 构造函数：根据给定的size初始化栈
     */
    Stack(){
        this(10);   //默认栈大小为10
    }
    
    Stack(int initialSize){
        if(initialSize >=0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
            top = -1;
        }else{
            throw new RuntimeException("初始化大小不能小于0：" + initialSize);
        }
    }
    
    //判空
    public boolean empty(){
        return top==-1 ? true : false;
    }
    
    //进栈,第一个元素top=0；
    public boolean push(E e){
        if(top == maxSize -1){
            throw new RuntimeException("栈已满，无法将元素入栈！");
        }else{
            data[++top]=e;
            return true;
        }    
    }
    
    //查看栈顶元素但不移除
    public E peek(){
        if(top == -1){
            throw new RuntimeException("栈为空！");
        }else{
            return (E)data[top];
        }
    }
    
    //弹出栈顶元素
    public E pop(){
        if(top == -1){
            throw new RuntimeException("栈为空！");
        }else{
            return (E)data[top--];
        }
    }
    
    //返回对象在堆栈中的位置，以 1 为基数
    public int search(E e){
        int i=top;
        while(top != -1){
            if(peek() != e){
                top --;
            }else{
                break;
            }
        }
        int result = top+1;
        top = i;
        return result;      
    }
    //获取栈中元素个数
    public int size(){
    return top;
}

基于数组实现的队列

public class ArrayQueue <T>
{
    private T[] queue;//队列数组
    private int head=0;//头下标
    private int tail=0;//尾下标
    private int count=0;//元素个数
    public ArrayQueue()
    {
        queue=(T[])new Object[10];
        this.head=0;//头下标为零
        this.tail=0;
        this.count=0;
    }
    public ArrayQueue(int size)
    {
        queue=(T[])new Object[size];
        this.head=0;
        this.tail=0;
        this.count=0;
    }
    //入队
    public boolean inQueue(T t)
    {
        if(count==queue.length)
            return false;
        queue[tail++%(queue.length)]=t;//如果不为空就放入下一个
        count++;
        return true;
    }
    //出队
    public T outQueue()
    {
        if(count==0)//如果是空的那就不能再出栈了
            return null;
        count--;
        return queue[head++%(queue.length)];
    }
    //查队头
    public T showHead()
    {
        if(count==0) return null;
        return queue[head];
    }
    //获取队列元素个数
    public int size()
    {
        return queue.length;
    }
    //判空
    public boolean isEmpty()
    {
        return count==0;
    }
    //
}