数据结构-队列的实现

数据结构-队列

队列是一种受限的线性表，其限制性在于它的插入操作在表的一端（也称队尾），删除操作在表的另一端（也称为队首），其主要操作如下：

• append（insert） 入队
• serve（delete）出队
• retrieve 读队首
• empty 判队为空
• front永远指向队首元素，队首是允许删除的一端
• rear永远指向队尾元素，队尾是允许插入的一端

利用数组实现顺序队列将面临“假溢出”的情况，到数组最后无法再插入元素，而数组前面可能造成空间浪费没有利用的情况，故队列的实现一般通过循环队列来 实现，即把存储队列数组看成一个环而不是一条直线。当rear指向数组边界马上溢出时，将指针修改为rear=0

---

本例中的循环队列通过C++模板类实现，实现思路及代码来自王治和教授数据结构课堂的总结

循环队列的c++实现

#include <iostream>
using namespace std;
const int maxqueue=5;
typedef char queue_entry;
enum error_code {success, overflow, underflow, fail};
class queue
{ protected:
    int front, rear;        //indicators of the front and rear
    queue_entry entry[maxqueue];
  public:
    queue();            //constructor
    bool empty() const;
    error_code serve();
    error_code append(const queue_entry &item);
    error_code retrieve(queue_entry &item) const;
    void print() const;
};

class extended_queue: public queue
{ public:
    extended_queue();      //constructor of derived class
    int size() const;
    void clear();
    bool full() const;
    error_code serve_and_retrieve(queue_entry &item);
};

queue::queue( )      //build an empty queue
{  front=0;
   rear=0;
}

bool queue::empty( ) const
{  return rear==front;  }

error_code queue::append(const queue_entry &item)
{ if ( (rear+1)%maxqueue==front)
    return overflow;
  entry[rear]=item;
  rear=(rear+1)%maxqueue;
  return success;
}

error_code queue::serve( )
{ if (rear==front)
    return underflow;
  front=(front+1)%maxqueue; 
  return success;
}

error_code queue::retrieve(queue_entry &item) const
{ if (front==rear)      //if (empty( ))
    return fail;
  item=entry[front];
  return success;
}
void queue::print() const
{ if (rear==front)
{cout<<"空队列"<<endl;
    return;
}
 if (rear>front)
   for(int i=front;i<rear;i++)
     cout<<entry[i]<<"  ";
 else
 { for(int i=front;i<maxqueue;i++)
     cout<<entry[i]<<"  ";
   for(int i=0;i<rear;i++)
     cout<<entry[i]<<"  ";
 }
 cout<<endl;
}

extended_queue::extended_queue():queue(){}

int extended_queue::size() const
{ 
    if (rear>=front)
        return rear-front;
    else
        return maxqueue+rear-front;
}

void extended_queue::clear()
{  
    front=rear=0;  
}

bool extended_queue::full() const
{  
    return (rear+1) % maxqueue==front;  
}

error_code extended_queue::serve_and_retrieve(queue_entry &item)
{ 
    if (front==rear)     
        return fail;
    item=entry[front];
    front=(front+1) % maxqueue; 
    return success;
}

编写测试代码

#include <iostream>
#include "queue.cpp"
#include <ctype.h>
using namespace std;
void help()
{ cout<<"A--append      S--serve     E--empty "<<endl;
  cout<<"#--size        P--print     Q--quit"<<endl;
}

char get_command()
{ char command;
  cout<<"输入一个操作命令: ";
  while(1)
  { cin>>command;
    command=toupper(command);
    if (command=='A'||command=='S'||command=='E'||command=='#'||command=='P'||command=='Q')
     break;
    else
     cout<<"输入一个有效操作命令: ";
  }
  return command;
}

bool do_command(char c, extended_queue &test_queue)
{ bool not_quit=true;
  char item;
  switch(c) {
   case 'A': 
     cout<<"输入一个字符: ";
     cin>>item;
     if (test_queue.append(item)==overflow)
       cout<<"队列已满"<<endl;
     break;
   case 'S':
     if(test_queue.serve()==underflow)
       cout<<"队列为空"<<endl;
     break;
   case 'E':
     if(test_queue.empty())
       cout<<"队列为空"<<endl;
     else
       cout<<"队列不为空"<<endl;
     break;
   case 'P':
     cout<<"队列内容是：";
     test_queue.print();
     break;
   case '#':
     cout<<"队列大小是：";
     cout<<test_queue.size()<<endl;
     break;
   case 'Q':not_quit=false;
  }
  return not_quit;
}

int main()
{ extended_queue test_queue;
  help();
  while(do_command(get_command(),test_queue));
  return 0;
}