数据结构Ｃ＋＋语言描述专题系列 （三） 队列

1、队列及其实现

队列的定义：在表的一端(rear)进行输入，在另一端(front)进行输出操作的表。
队列的特点：先进先出(FIFO)。

• 队列的抽象数据类型

ADT  Queue  is
  Data
        数据项列表
        front：队列中第一个数据项的位置
        rear： 队列中最后一个数据项的位置
        count：队列中元素的个数
  Operations
        Constructor        // 初始化队头和队尾
        append               // 入队列
        serve                  // 出队列
        retrieve              // 返回队列头部的元素的值
        empty                // 检测队列是否为空
end  ADT  Queue

• 类队列的声明与实现

类Queue的定义
class Queue
{
   protected:
       int front, rear, count;
       Queue_entry entry[maxqueue];
   public:
       Queue( ); 
       bool empty( ) const;
       Error_code append(const Queue_entry &x);
       Error_code serve( );
       Error_code retrieve(Queue_entry &x)  const;       
 }

• 派生类队列

队列中还有一些重要的方法如队列中的元素个数、清空队列、队列满测试等等。
采用C+ + 的派生类方法加以解决。

class Extended_queue: public Queue
{
    public:
       bool full( ) const;             // 测试派生类队列是否满
       int size( ) const;               // 返回派生类队列中元素个数
       void clear( );                    //  清空派生类队列
       Error_code serve_and_retrieve(Queue_entry &x);     //  返回派生 
                                                  类队列的头元素并修改队列头的位置
};

• 顺序队列的操作示意

在队列中有三个元素A、B、C

2、循环队列

指针移动用求余运算达到“循环”的目的。

• 循环队列的实现

Queue的构造函数
   Queue∷Queue( )
 /* Post: The Queue is initialized to be empty.  */   
 {
       count = 0;
       rear = maxqueue – 1
       front = 0
 }

函数空的测试
Bool Queue ∷empty( ) const
/* Post: Return true if the Queue is empty, otherwise return false. */
{
    return count = = 0;

入队列操作首先要判断队列是否满?(用记数判断队列满)
Error_code  Queue ∷append(const Queue_entry &item)
/* Post: item is added to the rear of the Queue. If the Queue is full return an Error_code of overflow and leave the Queue unchanged. */
{
   if (count > = maxqueue) return overflow;         // 判断队列是否满
   count + +;
   rear = (rear+1) % maxqueue;  // 修改队尾指针
   entry[rear] = item;          // 在队尾插入数据项
   return success;
 }

出队列操作
Error_code Queue∷serve( )
/* Post: The front of the Queue is removed. If the Queue is empty return an Error_code of underflow. */
{
   if (count< = 0)  return downflow;     // 判断队列是否为空
   count - -;
   front = (front+1) % maxqueue;         // 修改队头指针
   return  success;
}
检索队列头元素
Error_code Queue ∷retrieve ( Queue_entry &item) const
/* Post: The front of the Queue retrieved to the output parameter item. If the Queue is empty return an Error_code of underflow. */
{
   if (count< = 0)  return downflow;                 // 判断队列是否为空
   item = entry[front]; 
   return  success;
}

3、优先级队列

与一般队列的区别 ：出队列不是按入队列的先后次序，而是按数
据项本身的优先级，优先级高的先出队列。

count有多重作用：计数器，队尾指针
假定优先级最高的元素是值最小的元素，如
按优先级从高到低，上述任务次序为：
任务#2、任务#5、任务#1、任务#4、任务#3。
若没有新的任务加入，执行的次序(出队列的次序)应为
首先任务#2，其次任务#5、任务#1、任务#4，最后任务#3。

• 优先级队列的声明与实现

优先级队列的抽象数据类型
ADT  Priority Queue  is
Data
        元素组成的表
Operations
        Constructor
        Psize              //  返回队列中元素的个数
        Pempty          //  检测队列是否为空，空返回True，否则False
        Pappend        //  元素入队列，元素个数加1
        Pserve           //  优先级最高的元素出队列，元素个数减1
        Pclear            //  清空队列，并恢复到初始状态
        Pfull              //  检测队列是否为满，满返回True，否则False
end ADT Priority Queue


优先级队列的实现
PQueue 类的定义
class PQueue
{
   private:
      int  count;
      Queue_entry pentry[maxpqueue];
   public:
       //  构造函数
       Pqueue( );
       // 修改优先级队列的操作
       Error_code Pappend(const Queue_entry &item);
       Error_code Pserve( );
       Pclear( );
       // 检测优先级队列状态的操作
       bool Pempty( ) const;
       bool Pfull( ) const;
       bool Psize( ) const;
};

入队列操作

Error_code Pappend(const Queue_entry &item);
// 
PQueue ∷Pappend(const Queue_entry &item)
{
   if (count = = maxqueue)         //  队列满，退出
     {
           cerr<<“Priority queue overflow!”<<endl;
           exit(1);
      };
   pentry[count] = item;                  //  入队列，计数器加1
   count + +;
}

出队列操作

在队列非空的前提下，遍历队列以确定有最小值(即优先级最高)
的元素，删除之；并用队列尾元素代替这个元素(位置)，最后一
个元素除外。

出优先级队列函数
Error_code Pqueue∷ Pserve( )                 
{                                             
   Queue_entry min;                           
   int i,  minindex = 0;                      
   if (count＞0)                              
   {                                        
        //  在pqlist中寻找最小值及其下标       
        min = pentry[0];   //假设pentry[0]最小
        //  遍历队列，修改最小值及下标           
        for (i = 1;  i＜count;  i + +)        
              if (pentry[i] ＜min)            
              {  
                    //  新的最小值及其下标     
                    min = pentry[i];          
                    minindex = i;             
              };                          
              //将尾元素移入最小元素处并将count减1                             
              pentry[minindex] = pentry[count－1];      
              count - -;                                 
              }                                                
              // 若pqlist为空，则退出                        
              else                                              
              {                                           
                   出错，退出                                      
              };                                           
         return min;                                 
   }                                    

持续更新中。。。

数据结构Ｃ＋＋语言描述专题系列 （一） 绪论
数据结构Ｃ＋＋语言描述专题系列 （二） 栈
数据结构Ｃ＋＋语言描述专题系列 （三） 队列
数据结构Ｃ＋＋语言描述专题系列 （四） 链式栈和队列
数据结构Ｃ＋＋语言描述专题系列 （五） 递归
数据结构Ｃ＋＋语言描述专题系列 （六） 表与串
数据结构Ｃ＋＋语言描述专题系列 （七） 查找
数据结构Ｃ＋＋语言描述专题系列 （八） 排序
数据结构Ｃ＋＋语言描述专题系列 （九） 表与信息检索
数据结构Ｃ＋＋语言描述专题系列 （十） 二叉树
数据结构Ｃ＋＋语言描述专题系列 （十一） 多路数
数据结构Ｃ＋＋语言描述专题系列 （十二） 集合及其表
数据结构Ｃ＋＋语言描述专题系列 （十三） 图
数据结构Ｃ＋＋语言描述专题系列 （十四） 波兰表达式