算法练习之队列创建，循环队列

利用链表实现个队列

public class LinkQueue {

    public Node head;
    public Node tail;

    public LinkQueue() {
        this.head = this.tail=null;
    }


    //尾插法
    public void push(int m){		//入队列  O(1)
        Node node=new Node(m);
        if(tail==null){
            head=node;
            tail=node;
            head=tail;
        }else{
            tail.next=node;
            tail=tail.next;
        }
    }

    public int pop(){		//出队列 1 2 3 4 5 O(1) 很大的空间浪费
        if(isEmpty()){
            return 0;
        }
        int val=head.value;
        head=head.next;
        if(head==null){
            tail=null;
        }
        return val;

    }


    public boolean isEmpty(){
        if( tail ==null) return true;
        return false;
    }

    public static void main(String[] args) {
        LinkQueue aq=new LinkQueue();
        for (int i = 1; i <=10 ; i++) {
            aq.push(i);
        }
        for (int i = 1; i <=10; i++) {
            System.out.println(aq.pop());
        }

    }
}
class Node{
    public int value;
    public Node next;

    public Node(int value) {
        this.value = value;
        this.next=null;
    }
}

循环队列的构建

但是这种有个问题，就是剩余1个空间用不上

/**
 * 循环链表，得有个长度
 */
public class CircleQuene {
    private int data[];		// 数据
    private int head = 0;		//头
    private int tail = 0;		//尾
    private int n = 0;		//数组的大小 最大的空间

    public CircleQuene(int cap) {
        data = new int[cap];
        n = cap;
    }

    public int pop(){
        if(isEmpty()) return -1;
        int m=data[head];
        head=(head+1)%n;
        return m;
    }
    public void push(int m){
        //判断队列是否满了
        if( (tail+1)%n==head ){
            return ;
        }
        data[tail]=m;
        tail=(tail+1)%n;
    }

    public boolean isEmpty(){
        if(head==tail){
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        CircleQuene cq=new CircleQuene(10);
        for (int i = 1; i <= 10; i++) {
            cq.push(i);
        }
        System.out.println(cq.pop());
        System.out.println(cq.pop());
        System.out.println(cq.pop());
        System.out.println(cq.pop());
    }
}

所以还可以优化下，加个size，每次入队的时候size加1，每次出队的时候size减1

public class CircleQuene {
    private int data[];        // 数据
    private int head = 0;        //头
    private int tail = 0;        //尾
    private int n = 0;        //数组的大小 最大的空间
    private int size;//加了一个实际的size变量就可以了。
    public CircleQuene(int cap) {
        data = new int[cap];
        n = cap;
    }

    public int pop() {
        if (isEmpty()) return -1;
        int m = data[head];
        data[head]=0;
        head = (head + 1) % n;
        size--;
        return m;
    }

    public void push(int m) {
        //判断队列是否满了
        if(size==n){
            return;
        }
        data[tail] = m;
        tail = (tail + 1) % n;
        size++;
    }

    public boolean isEmpty() {
        if (size==0) {
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        CircleQuene cq = new CircleQuene(10);
        for (int i = 0; i <= 9; i++) {
            cq.push(i);
        }
        cq.push(10);
        for (int i = 0; i <= 9; i++) {
            System.out.println(cq.pop());
        }
    }
}