数据结构之队列

• 基本概念

队列是一种基本的数据结构，它在结构两端都有限制，插入只能在一段进行，而删除只能在另一端进行。允许删除的一端叫队尾，允许插入的一段叫队头。队列拥有先进先出的特点，又称为FIFO表。

• 代码实现
  队列根据其内部实现方式的不同，分为用链表实现的链队和用数组实现的顺序队。

链表实现：

public class Queue {
    private Node First;//定义头节点
    private Node Last;//定义尾节点
    private int count;//定义元素个数
    private class Node{//定义链表的节点
        Object obj;
        Node next;
        }

    public boolean isEmpty(){//判断队列是否为空的方法
        return count == 0;
    }

    public int Size() {//判断队列长度、元素个数的方法
        return count;
    }

    public void push(Object obj) {//添加元素的方法
        Node oldLast = Last;
        Last = new Node();
        Last.obj = obj;
        Last.next = null;
        if(isEmpty == true){
            First = Last;
        }else {
            oldLast.next = Last;
            }
        count++;
        }

    public Object Pop(){//删除元素的方法
        Object obj = First.obj;
        First = First.next;
        if(isEmpty() == true){
            Last = null;
            }
        count--;
        return obj;
        }
    }

接下来，我要用数组来实现队列。

public class Queue {
    private Object[] obj;
    private int First;
    private int Last;
    private Queue(int s) {
        obj = new Object[s];
        First = 0;
        Last = 0;
        }

    public boolean isEmpty(){
        return First == Last;
        }

    public boolean Size(){
        if(Last > First){
            return Last - First;
        }else {
            return obj.length-1;
            }

    public void push(Object ob){
        if((Last+1)%obj.length == First){
            System.out.println("不能进入，请弹出");
            }
        obj[Last] = ob;
        Last = (Last+1)%obj.length;
        System.out.println("进入成功");
        }

    public Object Pop(){
        if(First == Last){
            return null;
        }else {
        Object s = obj[First];
        First = (First+1)%obj.length;
        return s;
        }
    }
}