算法——Java实现队列

顺序队列：

概念：

队列是一种先进先出的线性表，只允许在一端插入，另一端删除。允许插入的一端称为队尾，允许删除的一端称为队头

顺序队列的实现：

import org.junit.jupiter.api.Test;

/**
 *   顺序队列
 * @author wydream
 *
 */

public class QueueSequence {

    private String[] arr;//队列数组
    private int end=0;//队尾标志
    
    //向队列中添加元素
    public void push(String[] arr,String value) {
        if(end<arr.length) {
            arr[end]=value;
            end++;
            return;
        }else {
            System.out.println("队列已经满了");
            return;
        }
        
    }
    
    //取出队列元素
    public String pop(String[] arr) {
        String rs;
        if(arr[0]==null) {
            System.out.println("队列为空,请先向队列中添加元素");
            return null;
        }else {
            rs=arr[0];
            arr[0]=null;
            move(arr);
            return rs;
        }
    }
    
    //队列元素向前移动
    public void move(String[] arr) {
        for(int i=0;i<arr.length-1;i++) {
            if(arr[i+1]!=null) {
                arr[i]=arr[i+1];
            }else{
                arr[i]=null;
                break;
            }
        }
    }
    
    
    
    
    @Test
    public void test() {
        String[] arr=new String[10];
        push(arr,"北京");
        push(arr,"上海");
        push(arr,"广东");
        push(arr,"杭州");
        push(arr,"苏州");
        push(arr,"扬州");
        pop(arr);
        pop(arr);
        pop(arr);
        pop(arr);
    }
    
}

循环队列：

概念：

• 顺序队列的不足：顺序队列在进行插入操作时，直接在队尾插入就可以，此时时间复杂度为O(1)，但是在出列是在队头，即下标为0的位置，也就意味着队列中所有的元素都得向前移动，此时时间复杂度为0(n)，效率较低。
• 队列出列时不需要所有的元素都移动，引入两个指针即可，一个头指针front指向队头元素，一个尾指针rear指向队尾元素，此时队列出列只需移动指针即可。但是此种情况下会出现一种溢出情况（如下图），此时队列中任然是有空间的可以存放元素的，但是尾指针已经溢出，于是就有了循环队列。
• 

  
  
  

• 
• front指向队头，rear指向队尾的下一个位置；队为空的判断：front==rear；队为满的判断：(rear+1)%MAXSIZE==front

 

实现循环队列：

/**
 *   java实现循环队列
 * @author wydream
 *
 */

import org.junit.jupiter.api.Test;

public class QueueArray {

    Object[] arr=new Object[10];;//对象数组，队列最多存储a.length-1个对象 
    int front=0;//队首下标
    int rear=0;//队尾下标
    
    /**
     *  将一个对象追加到队列尾部
     */
    public boolean enqueue(Object obj) {
        if((rear+1)%arr.length==front) {
            return false;
        }
        arr[rear]=obj;
        rear=(rear+1)%arr.length;
        return true;
    
    }
    
    //出队列
    public Object dequeue() {
        if(rear==front) {
            return null;
        }
        Object obj=arr[front];
        front=(front+1)%arr.length;
        return obj;
    }
    
    @Test
    public void test() {
        QueueArray q=new QueueArray();
        System.out.println(q.enqueue("北京"));
        System.out.println(q.enqueue("上海"));
        System.out.println(q.enqueue("广东"));
        System.out.println(q.enqueue("深圳"));
        for(int i=0;i<4;i++){   
            System.out.println(q.dequeue());   
        }   
    }
    
        
}