队列

队列

认识队列

同样可以使用数组或列表来简历一个队列，不过堆栈只需要一个top，指针指向对堆栈顶，而队列则必须使用front和rear两个指针分别指向前端和后端

队列的特征

 

1. 先进先出(FIFO)

2. 拥有两种基本操作，加入和删除，而且使用front与rear两个指针来分别指向队列的前端和尾端

队列的数组实现

 package 队列的数组实现;
 ​
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/8 19:13
  */
 public class Main {
     public static int front = -1,rear = -1, max = 3;
     public static int val;
     public static char ch;
     public static int queue[] = new int[max];
 ​
     public static void main(String[] args) throws IOException {
         String strM;
         int M = 0;
         BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
         while (rear < max-1 && M !=3)
         {
             System.out.println("[1]存入一个数值[2]取出一个数值[3]结束");
             strM = keyin.readLine();
             M = Integer.parseInt(strM);
             switch (M)
             {
                 case 1:
                     System.out.print("请输入数值");
                     strM = keyin.readLine();
                     val = Integer.parseInt(strM);
                     rear++;
                     queue[rear] = val;
                     break;
                 case 2:
                     if (rear > front)
                     {
                         front++;
                         System.out.print("取出数值为"+queue[front]);
                         queue[front] = 0;
                     }
                     else
                     {
                         System.out.println("列表已空");
                         break;
                     }
                     break;
                 default:
                     System.out.println();
                     break;
             }
         }
         if(rear == max-1) System.out.print("列表已经满了");
         System.out.println("目前列表中的数据");
         if (front >= rear)
         {
             System.out.println("没有");
             System.out.println("列表已经空了");
         }
         else
         {
             while(rear > front)
             {
                 front++;
                 System.out.println("["+queue[front]+"]");
             }
             System.out.println("\n");
         }
     }
 }
 ​

队列的链表实现

Node类

 package 链表建立队列;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/8 20:47
  */
 public class QueueNode {
     int data;
     QueueNode next;
     public QueueNode(int data)
     {
         this.data = data;
         next = null;
     }
 }
 ​

LinkList类

 package 链表建立队列;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/8 20:48
  */
 public class Linked_List_Queue {
     public QueueNode front;
     public QueueNode rear;
 ​
     public Linked_List_Queue()
     {
         front = null;
         rear = null;
     }
 ​
     public boolean enqueue(int value)
     {
         QueueNode node = new QueueNode(value);
         if (rear == null)
         {
             front = node;
         }
         else
         {
             rear.next = node;
         }
         rear = node;
         return true;
     }
     public int dequeue()
     {
         int value;
         if (!(front == null))
         {
             if (front == rear) rear=null;
             value = front.data;
             front = front.next;
             return value;
         }
         else return -1;
     }
 ​
 ​
 }
 ​

Main类

 package 链表建立队列;
 ​
 import java.io.IOException;
 ​
 /**
  * @author YanAemons
  * @date 2021/10/8 20:52
  */
 public class Main {
     public static void main(String[] args) throws IOException {
         Linked_List_Queue queue = new Linked_List_Queue();
         int temp;
         System.out.println("用链表来实现队列");
         System.out.println("===================================");
         System.out.println("插入数据1");
         queue.enqueue(1);
         System.out.println("插入数据2");
         queue.enqueue(2);
         System.out.println("插入数据3");
         queue.enqueue(3);
         System.out.println("===================================");
         while (true)
         {
             if (!(queue.front == null))
             {
                 temp = queue.dequeue();
                 System.out.println("从队列前端依次取出的数据值为"+temp);
             }
             else
             {
                 break;
             }
             break;
         }
 ​
     }
 }
 ​