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
         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
         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;
         }
      
       ```
      

你可能感兴趣的:(c++教程,数据结构)