队列(queue)

目录

队列的基本概念

队列的通过数组的简单实现

链表队列

链表队列的入队

链表队列的出队

---

队列的基本概念

        队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列插入队列即入队列，删除即为出队列， 队列具有先进先出的特性

        队列就像日常饭堂排队一样只能从队尾加入队列，等到排到队头的时候才能打饭。

• 假溢出：队列用的存储区还没有满,但队列却发生了溢出,我们把这种现象称为"假溢出"。

• 真溢出：由于队列的存储区不够而产生的溢出叫真溢出；

队列的通过数组的简单实现

实现队列的入队，若队列已满则无法入队，且需要避免假溢出问题。

实现队列的出队，若队列的为空也无法出队

队列的遍历，从队头开始遍历至队尾

​
​
public class Queue {                                                            
                                                                                
    private int front;    //队头                                                      
                                                                                
    private int rear;     //队尾                                                     
                                                                                
    private int maxSize;  //队列的最大长度                                                      
                                                                                
    private int size;     //队列的当前长度                                                      
                                                                                
    private int[] queue;  



                                                      
   //构造方法，初始化队列，设置队列大小                                                                             
    public Queue(int maxSize) {                                                 
        this.maxSize = maxSize;                                                 
        this.queue = new int[maxSize];                                          
                                                                                
    }   
 

                                                                       
     //构造方法，初始化队列，设置队列大小，默认为10                                                                               
    public Queue(){                                                             
          this.maxSize=10;                                                      
          this.queue=new int[maxSize];                                          
    } 

                                                                          
    //入队列                                                                            
    public void queuePush(int param) throws Exception{                          
        if(isFull()){                                                           
            throw new Exception("该队列已满");                                       
        }                                                                       
        queue[rear]=param;                                                      
        rear=(rear+1)%maxSize;//防止出现假溢出的情况                                                  
        size++;                                                                 
    }   



                                                                        
    //出队列                                                                            
    public int queuePop()throws Exception{                                      
        if(isEmpty()){                                                          
            throw new Exception("该队列为空");                                       
        }                                                                       
        int last=queue[front];                                                  
         front=(front+1)%maxSize;                                               
         size--;                                                                
         return last;                                                           
    }   

                                                                        
    //判断队列是否为空                                                                            
    public boolean isEmpty(){                                                   
          if(size==0){                                                          
              return true;                                                      
          }                                                                     
          return false;                                                         
                                                                                
    }   


    //遍历队列                                                                    
    public void forEach(){                                                      
        for(int i=0;i<size;i++){                                                
               System.out.println(queue[(i+front)%maxSize]);                    
        }                                                                       
    } 

                                                                       
    //判断队列是否溢出                                                                            
    public boolean isFull(){                                                    
        if(maxSize>size){                                                       
           return false;                                                        
        }                                                                       
        return true;                                                            
    }

}                                                                           

​

​

链表队列

• 基于链表实现的队列
• 该队列保存了队头与队尾的变量地址，这样可已方便操作，不需要手动搜索队尾，增加操作的时间。

链表队列的入队

• 初始化时将该队列的地址赋给队头。
• 该队列根据队尾的地址判断该队列是否为空。
• 判断队列是否为空，为空则添加数据到队头中去，并把队尾指向队头。
• 不为空则添加一个新LinkeaQueue数据至当前的队尾的next中去，并将队尾指向该变量地址。

链表队列的出队

• 判断该队列是否为空，为空抛出异常。
• 判断该队列的队头与队尾是否相同。
• 相同则将队尾地址设为null，并返回队头的数据（以为该队列判断是否为空的标准为队尾是否为空，为空则队列为空，否则反之）

                                                              初始化的时的链表队列

 添加了数据的链表数组

public class LinkedQueue {

    private int date;  //存储的数据

    private  LinkedQueue rear; //队尾

    private  LinkedQueue front;  //队头

    private  LinkedQueue next;  //节点连接下一个LinkedQueue

    //初始化的的队列，front不为null
    public LinkedQueue(){
        front=this;
    }

    //添加数据使用的构造方法
    public LinkedQueue(int date){
        this.date=date;
    }


      //入队
    public void queuePush(int date){
        if(isEmpty()){
            front.date=date;
            rear=front;
        }else {
            rear.next=new LinkedQueue(date);
            rear=rear.next;
        }
    }


    //出队
    public int  queuePop()throws Exception{
        if(isEmpty()){
            throw new Exception("该队列为空");
        }
        int first=front.date;
        if(front==rear){
            rear=null;
        }else {
            front=front.next;
        }
        return first;

    }
    //判断是否为空
    public boolean isEmpty(){
        if(rear==null){
            return true;
        }
        return false;
    }


    //遍历队列
    public void forEach(){
        if(!isEmpty()){
            LinkedQueue linkedQueue =front;
            do{
                System.out.println(linkedQueue.date);
                linkedQueue=linkedQueue.next;
            }while (linkedQueue!=rear);
            System.out.println(linkedQueue.date);
        }
    }

}