C++顺序队列&链式队列

队列

定义

• queue 队列也是一个线性存储表，元素数据的插入在表的一端进行，在另一端删除，从而构成了一个先进先出FIFO（First In First Out）表
• 数据插入：入队列
• 数据删除：出队列
• 先来先服务 先进先出
• 对头(front):允许删除的一端，队首
• 对尾(rear):允许插入的一端

队列的抽象数据类型描述

• 类型名称：队列
• 数据对象集：有穷线性表
• 操作集：
  • 初始化队列：Init_Queue(q) ，初始条件：队q 不存在。操作结果：构造了一个空队；
  • 入队操作： In_Queue(q,x),初始条件： 队q 存在。操作结果： 对已存在的队列q，插入一个元素x 到队尾，队发生变化；
  • 出队操作： Out_Queue(q,x)，初始条件: 队q 存在且非空，操作结果： 删除队首元素，并返回其值，队发生变化；
  • 读队头元素：Front_Queue(q,x)，初始条件: 队q 存在且非空，操作结果： 读队头元素，并返回其值，队不变；
  • 判队空操作：Empty_Queue(q)，初始条件： 队q 存在，操作结果： 若q 为空队则返回为1，否则返回为0

顺序存储

• 顺序队列
  • 队列的顺序实现是指分配一块连续的存储单元存放队列中的元素
  • 初始状态（对空条件）：front == rear = 0
  • 进队操作：队不满，先送值到队尾元素，再将队尾指针加1
  • 出队条件：对不空时，先取对头元素值，再将队头指针加1
• 循环队列

  • 把存储队列元素的表从逻辑上看成一个环，陈伟循环队列

  • 初始时：front=rear=0

  • 队首指针进1（进队）：front=(front+1)%Maxsize

  • 队尾指针进1（出队）：rear = (rear+1)%Maxsize

  • 队列长度：(rear+Maxsie-front)%Maxsie

  • 出队进队时：指针都是按顺时针方向进1

  • 缺点：

    • 无法判断堆满还是对空，因为此时front==rear
      • 为了解决该问题 有三种处理方法
      1. 牺牲一个单元区分队空和队满。入队时少用一个队列单元
         • 队满条件：(rear+1)%Maxsize == front
         • 队空条件：front==rear
         • 队列中元素的个数：(rear+Maxsie-front)%Maxsie
      2. 类型中增设表示元素个数的数据成员，这样，则队空的条件为size=0；队满条件为size=Maxsize
      3. 类型中增设tag数据成员，以区分是队满还是队空，tag等于0的情况下，若因删除frontrear则为空；tag1时，因插入导致front==rear则为队满

       //循环队列
       #include<iostream>
       using namespace std;
       const int MaxSize = 100;
      
       class queue
       {
       public:
           queue()
           {
               front = 0;
               rear = 0;
           }
           int isEmpty();
           int enqueue(int x);
           int  dequeue();
           void printqueue();
           int lengthqueue();
       private:
           int data[MaxSize];
           int front;
           int rear;
       };
      
       int queue::isEmpty()
       {
           if (front == rear)
           {
               return 1;
           }
           else
           {
               return 0;
           }
       }
      
       int queue::lengthqueue()
       {
           return (rear + MaxSize - front) % MaxSize;
       }
       int queue::enqueue(int x)
       {
           if ((rear + 1) % MaxSize == front)
           {
               cout << "队列满" << endl;
               return 0;
           }
           data[rear] = x;
           rear = (rear + 1) % MaxSize;
           return 1;
       }
       int  queue::dequeue()
       {
           if (isEmpty() == 1)
           {
               cout << "错误，队已空" << endl;
           }
           else
           {
               int x;
               x = data[front];
               front = (front + 1) % MaxSize;
               return x;
           }
       }
       void queue::printqueue()
       {
           if (isEmpty() == -1) throw"这是空栈";
           for (int i = front; i < front+lengthqueue(); i++)
           {
               cout << data[i] << endl;
           }
      
       }
       int main()
       {
           queue q;
           q.enqueue(1);
           q.enqueue(2);
           q.enqueue(3);
           q.enqueue(4);
           q.printqueue();
           cout<<q.dequeue()<<"de"<<endl;
           q.printqueue();
           cout << q.dequeue() << "de" << endl;
           q.printqueue();
           system("pause");
      
           return 0;
       }
      

  • 队列的链式存储

  • 注意点：当队列为空时，入队是front=rear=temp

       #include<iostream>
       using namespace std;
       class Node
       {
       public:
           Node(int x)
           {
               data = x;
               next = NULL;
           }
           int data;
           Node *next;
       };
    
       class queue
       {
       public:
           queue()
           {
               front = NULL;
               rear = NULL;
           }
           int isEmpty();
           void enqueue(int x);
           int dequeue();
           void printqueue();
    
       private:
           Node *front;
           Node *rear;
           int count=0;
       };
    
       int queue::isEmpty()
       {
           if (front == NULL)
           {
               return 1;
           }
           else
           {
               return 0;
           }
       }
    
       void queue::enqueue(int x)
       {
           Node *temp = new Node(x);
           if (isEmpty() == 1)
           {
               front = rear = temp;//注意点
           }
           else
           {
               rear->next = temp;
               rear = temp;
           }
    
           
       }
    
       int queue::dequeue()
       {
           if (isEmpty()==1)
           {
               cout << "队列为空" << endl;
               return -1;
           }
           else
           {
               Node *temp=front;
               front = front->next;
               return temp->data;
           }
       }
    
       void queue::printqueue()
       {
           Node *p = front;
           while (p != NULL)
           {
               cout << p->data;
               cout << " ";
               p = p->next;
           }
           cout << endl;
       }
       int main()
       {
           queue q;
           q.enqueue(1);
           q.enqueue(2);
           q.enqueue(3);
           q.enqueue(4);
           q.printqueue();
           cout << q.dequeue() <<"de"<< endl;
           cout << q.dequeue() << "de" << endl;
           q.printqueue();
           system("pause");
           return 0;
       }
    
     ```