[转]Queue基本操作

（java版）

import java.util.LinkedList;
//单向队列
public class Queue {
    public Queue() {
    }
    private LinkedList list = new LinkedList();
    public void put(Object v) {
        list.addFirst(v);
    }
    public Object get() {
        return list.removeLast();
    }
    public boolean isEmpty() {
        return list.isEmpty();
    }
}


import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
// 双向队列
public class DQueue implements Collection {
    private LinkedList lists;
    public DQueue() {
        lists = new LinkedList();
    }
    public void put_front(Object v) {
        lists.addFirst(v);
    }
    public void put_back(Object v) {
        lists.addLast(v);
    }
    public Object get_front() {
        return lists.removeFirst();
    }
    public Object get_Back() {
        return lists.removeLast();
    }
    public boolean isEmpty() {
        return lists.isEmpty();
    }
    public int size() {
        return lists.size();
    }
    public boolean contains(Object o) {
        return lists.contains(o);
    }
    public Iterator iterator() {
        return lists.iterator();
    }
    public Object[] toArray() {
        return lists.toArray();
    }
    public Object[] toArray(Object a[]) {
        return lists.toArray(a);
    }
    public boolean add(Object o) {
        lists.addLast(o);
        return true;
    }
    public boolean remove(Object o) {
        return lists.remove(o);
    }
    public boolean containsAll(Collection c) {
        return lists.containsAll(c);
    }
    public boolean addAll(Collection c) {
        return lists.addAll(c);
    }
    public boolean removeAll(Collection c) {
        return lists.removeAll(c);
    }
    public boolean retainAll(Collection c) {
        return lists.retainAll(c);
    }
    public void clear() {
        lists.clear();
    }
}

(C版)

队列也是表，使用队列时，插入在一端进行，而删除在另一端进行。

常用的操作：

/**是否为空队列**/

int isEmpty(Queue q)

/**队列是否已满**/

int isFull(Queue q)

/**实现循环队列，重置rear或者front**/

int circularQ(int index,Queue q)

/*入列*/

void enQueue(Queue q,int item)

/*出列*/

int deQueue(Queue q)

/**取队列头元素**/

int front(Queue q)

Queue.c

#include <stdio.h>
#include <stdlib.h>

typedef struct QueueRec{
    int front;
    int rear;
    int size;//队列元素个数
    int capacity;//队列大小
    int *Array;
} lqueue,*Queue;

int isEmpty(Queue q){
    return q->size==0;
}

int isFull(Queue q){
    return q->size==q->capacity;
}

Queue createQueue(int capacity){
    Queue queue;
    queue = (Queue)malloc(sizeof(lqueue));
    if(queue==NULL){
        return NULL;
    }
    queue->Array = malloc(sizeof(int)*capacity);
    if(queue->Array == NULL ){
        return NULL;
    }
    queue->capacity = capacity;
    queue->size = 0;
    queue->front = 0;
    queue->rear = -1;
    return queue;
}

void makEmpty(Queue q){
    q->size = 0;
    q->rear = -1;
    q->front = 0;
}

void disPoseQueue(Queue q){
    if(q!=NULL){
        free(q);
    }
}

/**这个方法实现循环队列，当rear到达尾端(入列)，或者front到达尾端(出列)，它又回到开头**/
int circularQ(int index,Queue q){
    if(++index > q->capacity){
        return 0;
    }
    return index;
}

/*入列*/
void enQueue(Queue q,int item){
    if(isFull(q)){
        printf("Queue is Full
");
    } else {
        q->size ++;
        q->rear = circularQ(q->rear,q);
        q->Array[q->rear] = item;
    }
}

/*出列*/
int deQueue(Queue q){
    int temp;
    if(isEmpty(q)){
        printf("queue is Empty
");
    } else {
        q->size --;
        temp = q->Array[q->front];
        q->front = circularQ(q->front,q);
    }
    return temp;
}

/**取队列头元素**/
int front(Queue q){
    return q->Array[q->front];
}

int main(void){
    Queue q = createQueue(5);
    enQueue(q,1);
    enQueue(q,2);
    enQueue(q,3);
    enQueue(q,4);
    enQueue(q,5);
    enQueue(q,6);
    printf("%d
",front(q));
    printf("%d
",deQueue(q));
    printf("%d
",deQueue(q));
    enQueue(q,7);
    printf("%d
",front(q));
    disPoseQueue(q);
    return -1;
}









小操作:
在java5中新增加了java.util.Queue接口，用以支持队列的常见操作。该接口扩展了java.util.Collection接口。Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失败的时候会抛出异常。 如果要使用前端而不移出该元素，使用element()或者peek()方法。值得注意的是LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。
小例子：

/**
 *
 * @author Zang XT
 */
import java.util.Queue;
import java.util.LinkedList;
public class TestQueue {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<String>();
        queue.offer("Hello");
        queue.offer("World!");
        queue.offer("你好！");
        System.out.println(queue.size());
        String str;
        while((str=queue.poll())!=null){
            System.out.print(str);
        }
        System.out.println();
        System.out.println(queue.size());
    }
}









(java版)
Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个 已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可 以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行得比第二个慢，则第二个 线程集在等待结果时就会阻塞。如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。下表显示了jdk1.5中的阻塞队列的操作：

add        增加一个元索                     如果队列已满，则抛出一个IIIegaISlabEepeplian异常remove   移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常element  返回队列头部的元素             如果队列为空，则抛出一个NoSuchElementException异常offer       添加一个元素并返回true       如果队列已满，则返回falsepoll         移除并返问队列头部的元素    如果队列为空，则返回nullpeek       返回队列头部的元素             如果队列为空，则返回nullput         添加一个元素                      如果队列满，则阻塞take        移除并返回队列头部的元素     如果队列为空，则阻塞

remove、element、offer 、poll、peek 其实是属于Queue接口。 

阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时 抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时 只是给出一个出错示而不会抛出异常。

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。

还有带超时的offer和poll方法变种，例如，下面的调用：boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：Object head = q.poll(100, TimeUnit.MILLISECONDS);如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。

最后，我们有阻塞操作put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

java.ulil.concurrent包提供了阻塞队列的4个变种。默认情况下，LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO（先进先出）排序元素。
ArrayBlockingQueue在构造时需要指定容量， 并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来 达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队 列，此队列按 FIFO（先进先出）原则对元素进行排序。
PriorityBlockingQueue是一个带优先级的 队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞 队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元 素要具有比较能力。
最后，DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。 下面是延迟接口：

Java代码

public interface Delayed extends Comparable {  
     long getDelay(TimeUnit unit);  
}  





放入DelayQueue的元素还将要实现compareTo方法，DelayQueue使用这个来为元素排序。

下面的实例展示了如何使用阻塞队列来控制线程集。程序在一个目录及它的所有子目录下搜索所有文件，打印出包含指定关键字的文件列表。从下面实例可以看出，使用阻塞队列两个显著的好处就是：多线程操作共同的队列时不需要额外的同步，另外就是队列会自动平衡负载，即那边（生产与消费两边）处理快了就会被阻塞掉，从而减少两边的处理速度差距。下面是具体实现：
Java代码

public class BlockingQueueTest {  
    public static void main(String[] args) {  
        Scanner in = new Scanner(System.in);  
        System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src): ");  
        String directory = in.nextLine();  
        System.out.print("Enter keyword (e.g. volatile): ");  
        String keyword = in.nextLine();  
  
        final int FILE_QUEUE_SIZE = 10;// 阻塞队列大小  
        final int SEARCH_THREADS = 100;// 关键字搜索线程个数  
  
        // 基于ArrayBlockingQueue的阻塞队列  
        BlockingQueue queue = new ArrayBlockingQueue(  
                FILE_QUEUE_SIZE);  
  
        //只启动一个线程来搜索目录  
        FileEnumerationTask enumerator = new FileEnumerationTask(queue,  
                new File(directory));  
        new Thread(enumerator).start();  
          
        //启动100个线程用来在文件中搜索指定的关键字  
        for (int i = 1; i <= SEARCH_THREADS; i++)  
            new Thread(new SearchTask(queue, keyword)).start();  
    }  
}  
class FileEnumerationTask implements Runnable {  
    //哑元文件对象，放在阻塞队列最后，用来标示文件已被遍历完  
    public static File DUMMY = new File("");  
  
    private BlockingQueue queue;  
    private File startingDirectory;  
  
    public FileEnumerationTask(BlockingQueue queue, File startingDirectory) {  
        this.queue = queue;  
        this.startingDirectory = startingDirectory;  
    }  
  
    public void run() {  
        try {  
            enumerate(startingDirectory);  
            queue.put(DUMMY);//执行到这里说明指定的目录下文件已被遍历完  
        } catch (InterruptedException e) {  
        }  
    }  
  
    // 将指定目录下的所有文件以File对象的形式放入阻塞队列中  
    public void enumerate(File directory) throws InterruptedException {  
        File[] files = directory.listFiles();  
        for (File file : files) {  
            if (file.isDirectory())  
                enumerate(file);  
            else  
                //将元素放入队尾，如果队列满，则阻塞  
                queue.put(file);  
        }  
    }  
}  
class SearchTask implements Runnable {  
    private BlockingQueue queue;  
    private String keyword;  
  
    public SearchTask(BlockingQueue queue, String keyword) {  
        this.queue = queue;  
        this.keyword = keyword;  
    }  
  
    public void run() {  
        try {  
            boolean done = false;  
            while (!done) {  
                //取出队首元素，如果队列为空，则阻塞  
                File file = queue.take();  
                if (file == FileEnumerationTask.DUMMY) {  
                    //取出来后重新放入，好让其他线程读到它时也很快的结束  
                    queue.put(file);  
                    done = true;  
                } else  
                    search(file);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        } catch (InterruptedException e) {  
        }  
    }  
    public void search(File file) throws IOException {  
        Scanner in = new Scanner(new FileInputStream(file));  
        int lineNumber = 0;  
        while (in.hasNextLine()) {  
            lineNumber++;  
            String line = in.nextLine();  
            if (line.contains(keyword))  
                System.out.printf("%s:%d:%s%n", file.getPath(), lineNumber,  
                        line);  
        }  
        in.close();  
    }  
}











java多线程和queue的使用

/*******公用的一个报警配置类*******************************************************/
public class AlarmConfig {//AlarmConfig 报警配置类
 public static final boolean FIND_ENABLE = true;//FINDENABLE 启用检测 public static final boolean FIND_UNABLE = false;//FINDUNABLE 关闭检测  当发生线程开启时，侦测线程是关闭的。 public static boolean ReceiveFind = FIND_UNABLE ;//ReceiveFind 接收检测    初始状态是关闭的 public static QueueArray queueArray =  new  QueueArray();//QueueArray 类里放这一个循环队列
 public AlarmConfig() { }
}
/***********循环队列类****************************************************/
public class QueueArray {//队列 private Object[] obj;   //初始化储存空间 private  int front;     //头指针,若队列不为空,指向队列头元素 private  int rear;      //尾指针,若队列不为空,指向队列尾元素的下一个位置
 public QueueArray() {  this(10); }
 public QueueArray(int size){  //队列进行初始化        obj=new Object[size];  front=0;  rear=0; } public Object dequeue(){//出队  if(rear==front){   return null;  }  Object ob=obj[front];  front=(front+1)%obj.length;  return ob; } public boolean enqueue(Object obje){//入队  if((rear+1)%obj.length==front){   return false;  }  obj[rear]=obje;  rear=(rear+1)%obj.length;  return true; } public static void main(String[] args) {      QueueArray d=new QueueArray(10);      for(int i=0;i<=20;i++){              System.out.println(i+"  "+ d.enqueue(i));          if(i>8){                 System.out.println(i+"  "+d.dequeue());             }      }  }}
/*********侦测线程****************************************************************/
public class MonitorThread implements Runnable{   //MonitorThread 是 侦测线程
 private Thread thread;  // 分配新的 线程 对象。 private boolean stop = true; public void strat() {//开启方法  if (stop) {//如果stop等于true 那么就给stop赋值false，然后开启一个线程
   thread = new Thread(this);// this 是其 run 方法被调用的对象
   stop = false;
   thread.start(); // 开始一个线程  }
 }
 public void stop() {//停止方法  stop = true;//给stop 赋值为true  thread = null; } 
 public void run() {  while (!stop) {
   if (AlarmConfig.ReceiveFind) {
    Object num=AlarmConfig.queueArray.dequeue();    System.out.println("检测接收:"+num);    look(num);    AlarmConfig.ReceiveFind = AlarmConfig.FIND_UNABLE;   }
   try {    Thread.sleep(100);   } catch (InterruptedException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }
  } }
 public void look(Object ob){   if(ob.equals(2)||ob.equals(12)){    System.out.println("报警!  发现错误报告! ======");   } }
}
/********发生器线程********************************************************************/
public class ThreadA implements Runnable {
 private Thread thread;// 分配新的 线程 对象。 private boolean stop = true;
 private int num = 1;
 public ThreadA() {// 无参的构造方法        //自动生成构造函数存根 }
 public void strat() {//开启方法  if (stop) {//如果stop等于true 那么就给stop赋值false，然后开启一个线程
   thread = new Thread(this);// this 是其 run 方法被调用的对象
   stop = false;
   thread.start(); // 开始一个线程   System.out.println("**当前stop为*******" + stop);  }
 }
 public void stop() {//停止方法  stop = true;//给stop 赋值为true  System.out.println(" stop true");  thread = null; }
 public void run() {  System.out.println("*test**");
  while (!stop) {
   if (!AlarmConfig.ReceiveFind) {
    System.out.println(num + " 发生器: "+ AlarmConfig.queueArray.enqueue(num));
    AlarmConfig.ReceiveFind = AlarmConfig.FIND_ENABLE;    num++;   }
   try {    Thread.sleep(100);   } catch (InterruptedException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }
  }
 }
}
/*************测试类******************************************************/
public class TestMainThread {
 public TestMainThread() {  // TODO Auto-generated constructor stub }
 public static void main(String[] args) {  ThreadA treadA = new ThreadA();  treadA.strat();  //treadA.stop();  MonitorThread monitorThread=new MonitorThread();  monitorThread.strat();  //monitorThread.stop();
 }
}




===================================================
（C版）

实验要求：
（1）编写链接队列的基本操作函数
1.进队函数 EnQueue(LinkQueue *Q,QElemType e)
2.出队函数 ，队空 DeQueue(LinkQueue *Q,QElemType e)
3.输出队列中元素  OutputQueue(LinkQueue *Q)

（2）调用上述函数实现下列操作，操作步骤如下
1.调用进队函数建立一个队列
2.读取队列中的第一个元素
2.从队列中删除元素
4.输出队列中的所有元素

（3）编写环形队列的基本操作函数
1.进队函数 EnQueue(SqQueue *Q,QElemType e)
2.出队函数 ，队空 DeQueue(SqQueue *Q,QElemType e)
3.输出队列中元素  OutputQueue(SqQueue *Q)
（4）调用上述函数实现下列操作，操作步骤如下
1.调用进队函数建立一个队列
2.读取队列中的第一个元素
2.从队列中删除元素
4.输出队列中的所有元素








1.链接队列：
#include<stdio.h>
#include<malloc.h>
typedef struct node
 {int data;
  struct node *next;
  };
typedef struct 
{struct node *front;
 struct node *rear;
}LinkQueue;

InitQueue(LinkQueue *Q)
{ Q->front=(struct node *)malloc(sizeof( struct node));
  Q->rear=Q->front;
  Q->front->next=NULL;
}

 EnQueue(LinkQueue *Q,int e)
{struct node *p;
 p=(struct node *)malloc(sizeof(struct node ));
 p->data=e;
 p->next=NULL;
 Q->rear->next=p;
 Q->rear=p; 
}

 DeQueue(LinkQueue *Q,int e)
{ struct node *p;
  if(Q->front==Q->rear)
return 0;

 else{
        p=Q->front->next;
        Q->front->next=p->next;
        if(p->next=NULL)Q->rear=Q->front;
        return(p->data);
        free(p);
  }
}

OutputQueue(LinkQueue *Q)
{ struct node *p;
 p=Q->front->next;
 while(p!=NULL)
 { printf("%d ",p->data);
   p=p->next;
 }
}

GetFront(LinkQueue *Q)
{  struct node *p;
   p=Q->front->next;
   printf("%d",p->data);
}


void main()
{ LinkQueue s;
  int i,max,e,item;
  InitQueue(&s);
  printf("put a max:");
  scanf("%d",&max);
  printf("shu ru yuan su");
  for(i=0;i<max;i++){ 
      scanf("%d",&e);
      EnQueue(&s,e);}
  OutputQueue(&s);
  printf("
");
  printf("di yi ge yuan su wei：");
  GetFront(&s);
  printf("
");
  printf("shu ru shan chu yuan su :");
  scanf("%d",&item);
  DeQueue(&s,item);
  OutputQueue(&s);
  printf("
");
}







2.环形队列：
#define MAXQSIZE 100
#include<stdio.h>
#include<malloc.h>
typedef struct{
 int *base;
 int front;
 int rear;
}SqQueue;

InitQueue(SqQueue *Q)
{ Q->base=(int *)malloc(MAXQSIZE * sizeof(int));
  if(!Q->base)exit(1);
  Q->front=Q->rear=0;
}

EnQueue(SqQueue *Q,int e)
{ Q->base[Q->rear]=e;
  Q->rear=(Q->rear+1)%MAXQSIZE;
}

DeQueue(SqQueue *Q,int *e)
{ if(Q->front==Q->rear)return 0;
  e=Q->base[Q->front];
  Q->front=(Q->front+1)%MAXQSIZE;
}

GetFront(SqQueue *Q)
{ if(Q->front==Q->rear)return 0;
  else printf("%d",Q->base[(Q->front)%MAXQSIZE]);
}

OutputQueue(SqQueue *Q)
{ int i;
  i=Q->front;
  if(!(Q->front==Q->rear))
  {
  while((i%MAXQSIZE)!=Q->rear)
   { printf("%d ",Q->base[i%MAXQSIZE]);
      i++;
   }
  }

}


void main()
{ SqQueue *s;
  int i,max,e,item;
  InitQueue(&s);
  printf("put a max:");
  scanf("%d",&max);
  printf("shu ru yuan su :");
  for(i=0;i<max;i++){ 
      scanf("%d",&e);
      EnQueue(&s,e);}
  OutputQueue(&s);
  printf("
");
  printf("di yi ge yuan su wei ：");
  GetFront(&s);
  printf("
");
  printf("shu ru shan chu yuan su:");
  scanf("%d",&item);
  DeQueue(&s,item);
  OutputQueue(&s);
}





===============================================================
（C版循环队列）

#include<iostream.h>
#include<malloc.h>
#include<stdlib.h>
#define  MAXSIZE   100  
#define TRUE 1
#define FALSE 0
typedef int DataType;
typedef  struct
{
  DataType   data[MAXSIZE]; 
  int front; //头指针指示器
  int rear;  //为指针指示器
}SeqQueue;

//初始化操作
void InitQueue(SeqQueue *Q)
{//将*Q初始化为一个空的循环队列
    Q->front=Q->rear=0;
}

//判断队列是否为空或满
void IsEmpty_full(SeqQueue *Q)
{
    if(Q->front==Q->rear)
        cout<<"该队列为空"<<endl;
    else if((Q->rear+1)%MAXSIZE==Q->front)
        cout<<"该队列为满"<<endl;
    else
        cout<<"该队列既不为空也不为满"<<endl;
}

//入队操作
int EnterQueue(SeqQueue *Q,DataType x)
{//将元素x入队
    if((Q->rear+1)%MAXSIZE==Q->front)  //队列已经满了
        return(FALSE);
    Q->data[Q->rear]=x;
    Q->rear=(Q->rear+1)%MAXSIZE; //重新设置队尾指针
    return(TRUE); //操作成功
}

//出队操作
int DeleteQueue(SeqQueue *Q,DataType *x)
{//删除队列的队头元素，用x返回其值
    if(Q->front==Q->rear) //队列为空
        return(FALSE);
    *x=Q->data[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;  //重新设置队头指针
    return(TRUE);  //操作成功
}

//清空元素
void ClearQueue_Sq(SeqQueue &Q)
{
    Q.front=Q.rear=0;
}

//构造队列，数据元素由键盘输入
void CreateQueue_Sq(SeqQueue &Q)

{
    DataType temp;
    cout<<"输入数据元素（按-1结束）"<<endl;
    cin>>temp;
    while(temp!=-1)
    {
        if((Q.rear+1)%MAXSIZE == Q.front)  cout<<"队列已经满了";
        else
        {
            Q.data[Q.rear]=temp;
            Q.rear=(Q.rear+1)%MAXSIZE;
            cin>>temp;
        }
    }
}

//队列的长度
int QueueLength_Sq(SeqQueue Q)
{
    return (Q.rear-Q.front+MAXSIZE) % MAXSIZE;
}

//由头到尾依次输出队列的数据元素
void OutputQueue_Sq(SeqQueue Q)
{
    if(Q.front==Q.rear) cout<<"空队列，没有元素"<<endl;
    else
    {
        cout<<"该循环队列各元素依次为：";
        for(int k=0; k<=QueueLength_Sq(Q)-1; k++)
            cout<<Q.data[(Q.front+k)%MAXSIZE]<<"  ";
        cout<<endl;
    }
}

void main()
{
   int flag=1,select;
   cout<<"                         ☆☆☆☆循环队列的基本操作☆☆☆☆"<<endl;
   cout<<"  ☆1.请输入循环队列元素：☆  "<<endl;
   cout<<"  ☆2.判断队列是否为空或是否为满☆"<<endl;
   cout<<"  ☆3.当前队头元素出队并将其输出循环队列的各元素☆  "<<endl;
   cout<<"  ☆4.将x入队并输出循环队列的各元素☆  "<<endl;
   cout<<"  ☆5.当前循环队列的长度☆  "<<endl;
   cout<<"  ☆6.清空队列☆  "<<endl;
   cout<<"  ☆7.退出☆  "<<endl;
  
while(flag)
{
    cout<<"请选择: ";
    cin>>select;
    SeqQueue Q;
    int x,a,e;
    switch(select)
    {
    case 1:
        InitQueue(&Q);
        CreateQueue_Sq(Q);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 2:
        IsEmpty_full(&Q);
        break;
        cout<<"请选择: ";
    case 3:
        DeleteQueue(&Q,&a);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 4:
        cout<<"请输入入队的元素x：";
        cin>>x;
        EnterQueue(&Q,x);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 5:
        cout<<"当前循环队列的长度是："<<(Q.rear-Q.front+MAXSIZE) % MAXSIZE<<endl;
        break;
        cout<<"请选择: ";
    case 6:
        ClearQueue_Sq(Q);
        cout<<"该循环队列已清空, ";
        break;
    case 7:
        flag=0;
        break;
    }
}
}



=============================================
(C版之基本操作)

队列是先进先出的数据结构，出队的一端叫队首，入队的一端叫队尾，就像是日常生活中排队买火车票一样，下面是队列的基本操作
#include <stdio.h>#include <string.h>#include <stdlib.h>typedef int QElemType;typedef struct QNode{    QElemType data;    struct QNode *next;}QNode,*QueuePtr;typedef struct{    QueuePtr front;    QueuePtr rear;}LinkQueue;int InitQueue(LinkQueue *Q);int DestroyQueue(LinkQueue *Q);int ClearQueue(LinkQueue *Q);int QueueEmpty(LinkQueue Q);int QueueLength(LinkQueue Q);int GetHead(LinkQueue Q,QElemType *e);int InsertQueue(LinkQueue *Q,QElemType e);int DelQueue(LinkQueue *Q,QElemType *e);int PrintQueue(LinkQueue Q);
int InitQueue(LinkQueue *Q){    Q->front = Q->rear = (QueuePtr )malloc(sizeof(QNode));    if(!Q->front)    {        perror("malloc error
");        return -1;    }    Q->front->next = NULL;    Q->front->data = 0;    return 0;}int DestroyQueue(LinkQueue *Q){    while(Q->front)    {        Q->rear = Q->front->next;        free(Q->front);        Q->front = Q->rear;    }    Q = NULL;    return 0;}int ClearQueue(LinkQueue *Q){    return 0;}int QueueEmpty(LinkQueue Q){    if(Q.front == Q.rear)    {        return 1;    }    else    {        return 0;    }}int QueueLength(LinkQueue Q){    return Q.front->data;}int GetHead(LinkQueue Q,QElemType *e){    if(Q.front->next == NULL)    {        perror("Queue is empty!
");        *e = -1;        return -1;    }    *e = Q.front->next->data;    return 0;}int InsertQueue(LinkQueue *Q,QElemType e){    QueuePtr p = (QueuePtr )malloc(sizeof(QNode));    if(p == NULL)    {        perror("malloc error!
");        return -1;    }    p->data = e;    p->next = NULL;    (Q->rear)->next = p;    Q->rear = p;    Q->front->data++;    return 0;}int DelQueue(LinkQueue *Q,QElemType *e){    if(Q->front == Q->rear)    {        perror("The queue is empty!");        return -1;    }    QueuePtr p = (QueuePtr )malloc(sizeof(QNode));    p = Q->front->next;    *e = p->data;    Q->front->next = p->next;    if(Q->rear == p)    {        Q->rear = Q->front;    }    free(p);    Q->front->data--;    return 0;}int PrintQueue(LinkQueue Q){    Q.front = Q.front->next;    while(Q.front != NULL)    {        printf("%d-----",Q.front->data);        Q.front = Q.front->next;    }    return 0;}



=========================================
(C版之基本操作)

1.链式队列
//队列结点结构体
typedef struct QNode
{ QElemType data;
  QNode *next;
}*Queueptr;
------------------------------
//指向结点的指针
struct LinkQueue
{  Queueptr front,rear;
}
<STRONG><SPAN style="COLOR: #000066; FONT-SIZE: 18px">void InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
  if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
    exit(OVERFLOW);
  Q.front->next=NULL;
}

void DestroyQueue(LinkQueue &Q)
{ // 销毁队列Q(无论空否均可)
  while(Q.front)
  {
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;//释放一块内存要做两点：1.释放指向它的指针。2.将该指针指向空
  }
}

void ClearQueue(LinkQueue &Q)
{ // 将Q清为空队列
  QueuePtr p,q;
  Q.rear=Q.front;
  p=Q.front->next;
  Q.front->next=NULL;//只留下头结点
  while(p)
  {
    q=p;
    p=p->next;
    free(q);
  }
}

Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
  if(Q.front->next==NULL)//注意不要把链式队列的判空条件与循环队列混淆
    return TRUE;
  else
    return FALSE;
}

int QueueLength(LinkQueue Q)
{ // 求队列的长度
  int i=0;
  QueuePtr p;
  p=Q.front;
  while(Q.rear!=p)
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetHead(LinkQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  return OK;
}

void EnQueue(LinkQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
  QueuePtr p;
  if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
    exit(OVERFLOW);
  p->data=e;
  p->next=NULL;
  Q.rear->next=p;
  Q.rear=p;
}

Status DeQueue(LinkQueue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  Q.front->next=p->next;
  if(Q.rear==p)
    Q.rear=Q.front;//如果只有一个节点，那么删除这个节点后rear指针也就丢了，需重新赋值
  free(p);
  return OK;
}

void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
  QueuePtr p;
  p=Q.front->next;
  while(p)
  {
    vi(p->data);
    p=p->next;
  }
  printf("
");
}</SPAN></STRONG>
<strong><span style="font-size:18px;color:#000066;">void InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
  if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
    exit(OVERFLOW);
  Q.front->next=NULL;
}

void DestroyQueue(LinkQueue &Q)
{ // 销毁队列Q(无论空否均可)
  while(Q.front)
  {
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;//释放一块内存要做两点：1.释放指向它的指针。2.将该指针指向空
  }
}

void ClearQueue(LinkQueue &Q)
{ // 将Q清为空队列
  QueuePtr p,q;
  Q.rear=Q.front;
  p=Q.front->next;
  Q.front->next=NULL;//只留下头结点
  while(p)
  {
    q=p;
    p=p->next;
    free(q);
  }
}

Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
  if(Q.front->next==NULL)//注意不要把链式队列的判空条件与循环队列混淆
    return TRUE;
  else
    return FALSE;
}

int QueueLength(LinkQueue Q)
{ // 求队列的长度
  int i=0;
  QueuePtr p;
  p=Q.front;
  while(Q.rear!=p)
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetHead(LinkQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  return OK;
}

void EnQueue(LinkQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
  QueuePtr p;
  if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
    exit(OVERFLOW);
  p->data=e;
  p->next=NULL;
  Q.rear->next=p;
  Q.rear=p;
}

Status DeQueue(LinkQueue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  Q.front->next=p->next;
  if(Q.rear==p)
    Q.rear=Q.front;//如果只有一个节点，那么删除这个节点后rear指针也就丢了，需重新赋值
  free(p);
  return OK;
}

void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
  QueuePtr p;
  p=Q.front->next;
  while(p)
  {
    vi(p->data);
    p=p->next;
  }
  printf("
");
}</span></strong>
2.顺序队列---循环队列
性质如下:
1.头指针指向对头元素，尾指针指向队尾的下一个位置。(这里的指针都是为指针，实际是数组序号)
2.为了区分队满与对空，则定义一个存储空间为MAX_QSIZE大小的队列只允许存放MAX_QSIZE-1个数据。
3.判空条件为:if(Q.front ==Q.rear) return true;
   判满条件为:if((Q.rear+1)%MAX_QSIZE==Q.front) return true;
4.循环队列的长度为:(Q.read-Q.front+MAX_SIZE)%MAX_QSIZE
5.当删除对头元素或者在对尾插入元素时指针均需向后移动。操作为:
    Q.rear=(Q.rear+1)%MAX_QSIZE;
    Q.front=(Q.front+1)%MAX_QSIZE;
结构体定义如下:
struct SqQueue
{QElemType *base;//指向开辟的空间的首地址
  int front;
  int rear;
}
void InitQueue(SqQueue &Q)
 { // 构造一个空队列Q
   Q.base=(QElemType *)malloc(MAX_QSIZE*sizeof(QElemType));
   if(!Q.base) // 存储分配失败
     exit(OVERFLOW);
   Q.front=Q.rear=0;
 }

 void DestroyQueue(SqQueue &Q)
 { // 销毁队列Q，Q不再存在
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
 }

 void ClearQueue(SqQueue &Q)
 { // 将Q清为空队列
   Q.front=Q.rear=0;
 }

 Status QueueEmpty(SqQueue Q)
 { // 若队列Q为空队列，则返回TRUE；否则返回FALSE
   if(Q.front==Q.rear) // 队列空的标志
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(SqQueue Q)
 { // 返回Q的元素个数，即队列的长度
   return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;
 }

 Status GetHead(SqQueue Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];//等价于e=*(Q.base+Q.front)
   return OK;
 }

 Status EnQueue(SqQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素
   if((Q.rear+1)%MAX_QSIZE==Q.front) // 队列满
     return ERROR;
   Q.base[Q.rear]=e;//等价于*(Q.base+Q.rear)=e
   Q.rear=(Q.rear+1)%MAX_QSIZE;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAX_QSIZE;
   return OK;
 }

 void QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi()
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(Q.base[i]);
     i=(i+1)%MAX_QSIZE;
   }
   printf("
");
 }
/*
 * 用数组实现一个两端都能插入和删除操作的双端队列
 */

static const int nLength = 5;
static int deque[nLength];
static int nIdxHead = 0;
static int nIdxTail = 0;

enum Err
{
    NoErr,
    errOverFlow,
    errUnderFlow,
};

// 头进队
Err EnDequeHead(int x)
{
    if (((nIdxHead + nLength - 1) % nLength) == nIdxTail)
        return errOverFlow;
    nIdxHead = ((nIdxHead + nLength - 1) % nLength);
    deque[nIdxHead] = x;
    return NoErr;
}

// 头出队
Err DeDequeHead(int *pX)
{
    if (nIdxHead == nIdxTail)
        return errUnderFlow;
    if (NULL != pX)
        *pX = deque[nIdxHead];
    nIdxHead = (nIdxHead + 1) % nLength;
    return NoErr;
}

// 尾进队
Err EnDequeTail(int x)
{
    if (((nIdxTail + 1) % nLength) == nIdxHead)
        return errOverFlow;
    deque[nIdxTail] = x;
    nIdxTail = ((nIdxTail + 1) % nLength);
    return NoErr;
}

// 尾出队
Err DeDequeTail(int *pX)
{
    if (nIdxHead == nIdxTail)
        return errUnderFlow;
    nIdxTail = (nIdxTail + nLength - 1) % nLength;
    if (NULL != pX)
        *pX = deque[nIdxTail];
    return NoErr;
}
public interface Delayed extends Comparable {
     long getDelay(TimeUnit unit);
}
public class BlockingQueueTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src): ");
        String directory = in.nextLine();
        System.out.print("Enter keyword (e.g. volatile): ");
        String keyword = in.nextLine();

        final int FILE_QUEUE_SIZE = 10;// 阻塞队列大小
        final int SEARCH_THREADS = 100;// 关键字搜索线程个数

        // 基于ArrayBlockingQueue的阻塞队列
        BlockingQueue queue = new ArrayBlockingQueue(
                FILE_QUEUE_SIZE);

        //只启动一个线程来搜索目录
        FileEnumerationTask enumerator = new FileEnumerationTask(queue,
                new File(directory));
        new Thread(enumerator).start();

        //启动100个线程用来在文件中搜索指定的关键字
        for (int i = 1; i <= SEARCH_THREADS; i++)
            new Thread(new SearchTask(queue, keyword)).start();
    }
}
class FileEnumerationTask implements Runnable {
    //哑元文件对象，放在阻塞队列最后，用来标示文件已被遍历完
    public static File DUMMY = new File("");

    private BlockingQueue queue;
    private File startingDirectory;

    public FileEnumerationTask(BlockingQueue queue, File startingDirectory) {
        this.queue = queue;
        this.startingDirectory = startingDirectory;
    }

    public void run() {
        try {
            enumerate(startingDirectory);
            queue.put(DUMMY);//执行到这里说明指定的目录下文件已被遍历完
        } catch (InterruptedException e) {
        }
    }

    // 将指定目录下的所有文件以File对象的形式放入阻塞队列中
    public void enumerate(File directory) throws InterruptedException {
        File[] files = directory.listFiles();
        for (File file : files) {
            if (file.isDirectory())
                enumerate(file);
            else
                //将元素放入队尾，如果队列满，则阻塞
                queue.put(file);
        }
    }
}
class SearchTask implements Runnable {
    private BlockingQueue queue;
    private String keyword;

    public SearchTask(BlockingQueue queue, String keyword) {
        this.queue = queue;
        this.keyword = keyword;
    }

    public void run() {
        try {
            boolean done = false;
            while (!done) {
                //取出队首元素，如果队列为空，则阻塞
                File file = queue.take();
                if (file == FileEnumerationTask.DUMMY) {
                    //取出来后重新放入，好让其他线程读到它时也很快的结束
                    queue.put(file);
                    done = true;
                } else
                    search(file);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
        }
    }
    public void search(File file) throws IOException {
        Scanner in = new Scanner(new FileInputStream(file));
        int lineNumber = 0;
        while (in.hasNextLine()) {
            lineNumber++;
            String line = in.nextLine();
            if (line.contains(keyword))
                System.out.printf("%s:%d:%s%n", file.getPath(), lineNumber,
                        line);
        }
        in.close();
    }
}











java多线程和queue的使用
/*******公用的一个报警配置类*******************************************************/
public class AlarmConfig {//AlarmConfig 报警配置类
 public static final boolean FIND_ENABLE = true;//FINDENABLE 启用检测 public static final boolean FIND_UNABLE = false;//FINDUNABLE 关闭检测  当发生线程开启时，侦测线程是关闭的。 public static boolean ReceiveFind = FIND_UNABLE ;//ReceiveFind 接收检测    初始状态是关闭的 public static QueueArray queueArray =  new  QueueArray();//QueueArray 类里放这一个循环队列
 public AlarmConfig() { }
}
/***********循环队列类****************************************************/
public class QueueArray {//队列 private Object[] obj;   //初始化储存空间 private  int front;     //头指针,若队列不为空,指向队列头元素 private  int rear;      //尾指针,若队列不为空,指向队列尾元素的下一个位置
 public QueueArray() {  this(10); }
 public QueueArray(int size){  //队列进行初始化        obj=new Object[size];  front=0;  rear=0; } public Object dequeue(){//出队  if(rear==front){   return null;  }  Object ob=obj[front];  front=(front+1)%obj.length;  return ob; } public boolean enqueue(Object obje){//入队  if((rear+1)%obj.length==front){   return false;  }  obj[rear]=obje;  rear=(rear+1)%obj.length;  return true; } public static void main(String[] args) {      QueueArray d=new QueueArray(10);      for(int i=0;i<=20;i++){              System.out.println(i+"  "+ d.enqueue(i));          if(i>8){                 System.out.println(i+"  "+d.dequeue());             }      }  }}
/*********侦测线程****************************************************************/
public class MonitorThread implements Runnable{   //MonitorThread 是 侦测线程
 private Thread thread;  // 分配新的 线程 对象。 private boolean stop = true; public void strat() {//开启方法  if (stop) {//如果stop等于true 那么就给stop赋值false，然后开启一个线程
   thread = new Thread(this);// this 是其 run 方法被调用的对象
   stop = false;
   thread.start(); // 开始一个线程  }
 }
 public void stop() {//停止方法  stop = true;//给stop 赋值为true  thread = null; } 
 public void run() {  while (!stop) {
   if (AlarmConfig.ReceiveFind) {
    Object num=AlarmConfig.queueArray.dequeue();    System.out.println("检测接收:"+num);    look(num);    AlarmConfig.ReceiveFind = AlarmConfig.FIND_UNABLE;   }
   try {    Thread.sleep(100);   } catch (InterruptedException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }
  } }
 public void look(Object ob){   if(ob.equals(2)||ob.equals(12)){    System.out.println("报警!  发现错误报告! ======");   } }
}
/********发生器线程********************************************************************/
public class ThreadA implements Runnable {
 private Thread thread;// 分配新的 线程 对象。 private boolean stop = true;
 private int num = 1;
 public ThreadA() {// 无参的构造方法        //自动生成构造函数存根 }
 public void strat() {//开启方法  if (stop) {//如果stop等于true 那么就给stop赋值false，然后开启一个线程
   thread = new Thread(this);// this 是其 run 方法被调用的对象
   stop = false;
   thread.start(); // 开始一个线程   System.out.println("**当前stop为*******" + stop);  }
 }
 public void stop() {//停止方法  stop = true;//给stop 赋值为true  System.out.println(" stop true");  thread = null; }
 public void run() {  System.out.println("*test**");
  while (!stop) {
   if (!AlarmConfig.ReceiveFind) {
    System.out.println(num + " 发生器: "+ AlarmConfig.queueArray.enqueue(num));
    AlarmConfig.ReceiveFind = AlarmConfig.FIND_ENABLE;    num++;   }
   try {    Thread.sleep(100);   } catch (InterruptedException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }
  }
 }
}
/*************测试类******************************************************/
public class TestMainThread {
 public TestMainThread() {  // TODO Auto-generated constructor stub }
 public static void main(String[] args) {  ThreadA treadA = new ThreadA();  treadA.strat();  //treadA.stop();  MonitorThread monitorThread=new MonitorThread();  monitorThread.strat();  //monitorThread.stop();
 }
}

===================================================
（C版）
实验要求：
（1）编写链接队列的基本操作函数
1.进队函数 EnQueue(LinkQueue *Q,QElemType e)
2.出队函数 ，队空 DeQueue(LinkQueue *Q,QElemType e)
3.输出队列中元素  OutputQueue(LinkQueue *Q)

（2）调用上述函数实现下列操作，操作步骤如下
1.调用进队函数建立一个队列
2.读取队列中的第一个元素
2.从队列中删除元素
4.输出队列中的所有元素

（3）编写环形队列的基本操作函数
1.进队函数 EnQueue(SqQueue *Q,QElemType e)
2.出队函数 ，队空 DeQueue(SqQueue *Q,QElemType e)
3.输出队列中元素  OutputQueue(SqQueue *Q)
（4）调用上述函数实现下列操作，操作步骤如下
1.调用进队函数建立一个队列
2.读取队列中的第一个元素
2.从队列中删除元素
4.输出队列中的所有元素








1.链接队列：
#include<stdio.h>
#include<malloc.h>
typedef struct node
 {int data;
  struct node *next;
  };
typedef struct 
{struct node *front;
 struct node *rear;
}LinkQueue;

InitQueue(LinkQueue *Q)
{ Q->front=(struct node *)malloc(sizeof( struct node));
  Q->rear=Q->front;
  Q->front->next=NULL;
}

 EnQueue(LinkQueue *Q,int e)
{struct node *p;
 p=(struct node *)malloc(sizeof(struct node ));
 p->data=e;
 p->next=NULL;
 Q->rear->next=p;
 Q->rear=p; 
}

 DeQueue(LinkQueue *Q,int e)
{ struct node *p;
  if(Q->front==Q->rear)
return 0;

 else{
        p=Q->front->next;
        Q->front->next=p->next;
        if(p->next=NULL)Q->rear=Q->front;
        return(p->data);
        free(p);
  }
}

OutputQueue(LinkQueue *Q)
{ struct node *p;
 p=Q->front->next;
 while(p!=NULL)
 { printf("%d ",p->data);
   p=p->next;
 }
}

GetFront(LinkQueue *Q)
{  struct node *p;
   p=Q->front->next;
   printf("%d",p->data);
}


void main()
{ LinkQueue s;
  int i,max,e,item;
  InitQueue(&s);
  printf("put a max:");
  scanf("%d",&max);
  printf("shu ru yuan su");
  for(i=0;i<max;i++){ 
      scanf("%d",&e);
      EnQueue(&s,e);}
  OutputQueue(&s);
  printf("
");
  printf("di yi ge yuan su wei：");
  GetFront(&s);
  printf("
");
  printf("shu ru shan chu yuan su :");
  scanf("%d",&item);
  DeQueue(&s,item);
  OutputQueue(&s);
  printf("
");
}







2.环形队列：
#define MAXQSIZE 100
#include<stdio.h>
#include<malloc.h>
typedef struct{
 int *base;
 int front;
 int rear;
}SqQueue;

InitQueue(SqQueue *Q)
{ Q->base=(int *)malloc(MAXQSIZE * sizeof(int));
  if(!Q->base)exit(1);
  Q->front=Q->rear=0;
}

EnQueue(SqQueue *Q,int e)
{ Q->base[Q->rear]=e;
  Q->rear=(Q->rear+1)%MAXQSIZE;
}

DeQueue(SqQueue *Q,int *e)
{ if(Q->front==Q->rear)return 0;
  e=Q->base[Q->front];
  Q->front=(Q->front+1)%MAXQSIZE;
}

GetFront(SqQueue *Q)
{ if(Q->front==Q->rear)return 0;
  else printf("%d",Q->base[(Q->front)%MAXQSIZE]);
}

OutputQueue(SqQueue *Q)
{ int i;
  i=Q->front;
  if(!(Q->front==Q->rear))
  {
  while((i%MAXQSIZE)!=Q->rear)
   { printf("%d ",Q->base[i%MAXQSIZE]);
      i++;
   }
  }

}


void main()
{ SqQueue *s;
  int i,max,e,item;
  InitQueue(&s);
  printf("put a max:");
  scanf("%d",&max);
  printf("shu ru yuan su :");
  for(i=0;i<max;i++){ 
      scanf("%d",&e);
      EnQueue(&s,e);}
  OutputQueue(&s);
  printf("
");
  printf("di yi ge yuan su wei ：");
  GetFront(&s);
  printf("
");
  printf("shu ru shan chu yuan su:");
  scanf("%d",&item);
  DeQueue(&s,item);
  OutputQueue(&s);
}


===============================================================
（C版循环队列）
#include<iostream.h>
#include<malloc.h>
#include<stdlib.h>
#define  MAXSIZE   100  
#define TRUE 1
#define FALSE 0
typedef int DataType;
typedef  struct
{
  DataType   data[MAXSIZE]; 
  int front; //头指针指示器
  int rear;  //为指针指示器
}SeqQueue;

//初始化操作
void InitQueue(SeqQueue *Q)
{//将*Q初始化为一个空的循环队列
    Q->front=Q->rear=0;
}

//判断队列是否为空或满
void IsEmpty_full(SeqQueue *Q)
{
    if(Q->front==Q->rear)
        cout<<"该队列为空"<<endl;
    else if((Q->rear+1)%MAXSIZE==Q->front)
        cout<<"该队列为满"<<endl;
    else
        cout<<"该队列既不为空也不为满"<<endl;
}

//入队操作
int EnterQueue(SeqQueue *Q,DataType x)
{//将元素x入队
    if((Q->rear+1)%MAXSIZE==Q->front)  //队列已经满了
        return(FALSE);
    Q->data[Q->rear]=x;
    Q->rear=(Q->rear+1)%MAXSIZE; //重新设置队尾指针
    return(TRUE); //操作成功
}

//出队操作
int DeleteQueue(SeqQueue *Q,DataType *x)
{//删除队列的队头元素，用x返回其值
    if(Q->front==Q->rear) //队列为空
        return(FALSE);
    *x=Q->data[Q->front];
    Q->front=(Q->front+1)%MAXSIZE;  //重新设置队头指针
    return(TRUE);  //操作成功
}

//清空元素
void ClearQueue_Sq(SeqQueue &Q)
{
    Q.front=Q.rear=0;
}

//构造队列，数据元素由键盘输入
void CreateQueue_Sq(SeqQueue &Q)

{
    DataType temp;
    cout<<"输入数据元素（按-1结束）"<<endl;
    cin>>temp;
    while(temp!=-1)
    {
        if((Q.rear+1)%MAXSIZE == Q.front)  cout<<"队列已经满了";
        else
        {
            Q.data[Q.rear]=temp;
            Q.rear=(Q.rear+1)%MAXSIZE;
            cin>>temp;
        }
    }
}

//队列的长度
int QueueLength_Sq(SeqQueue Q)
{
    return (Q.rear-Q.front+MAXSIZE) % MAXSIZE;
}

//由头到尾依次输出队列的数据元素
void OutputQueue_Sq(SeqQueue Q)
{
    if(Q.front==Q.rear) cout<<"空队列，没有元素"<<endl;
    else
    {
        cout<<"该循环队列各元素依次为：";
        for(int k=0; k<=QueueLength_Sq(Q)-1; k++)
            cout<<Q.data[(Q.front+k)%MAXSIZE]<<"  ";
        cout<<endl;
    }
}

void main()
{
   int flag=1,select;
   cout<<"                         ☆☆☆☆循环队列的基本操作☆☆☆☆"<<endl;
   cout<<"  ☆1.请输入循环队列元素：☆  "<<endl;
   cout<<"  ☆2.判断队列是否为空或是否为满☆"<<endl;
   cout<<"  ☆3.当前队头元素出队并将其输出循环队列的各元素☆  "<<endl;
   cout<<"  ☆4.将x入队并输出循环队列的各元素☆  "<<endl;
   cout<<"  ☆5.当前循环队列的长度☆  "<<endl;
   cout<<"  ☆6.清空队列☆  "<<endl;
   cout<<"  ☆7.退出☆  "<<endl;
  
while(flag)
{
    cout<<"请选择: ";
    cin>>select;
    SeqQueue Q;
    int x,a,e;
    switch(select)
    {
    case 1:
        InitQueue(&Q);
        CreateQueue_Sq(Q);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 2:
        IsEmpty_full(&Q);
        break;
        cout<<"请选择: ";
    case 3:
        DeleteQueue(&Q,&a);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 4:
        cout<<"请输入入队的元素x：";
        cin>>x;
        EnterQueue(&Q,x);
        OutputQueue_Sq(Q);
        break;
        cout<<"请选择: ";
    case 5:
        cout<<"当前循环队列的长度是："<<(Q.rear-Q.front+MAXSIZE) % MAXSIZE<<endl;
        break;
        cout<<"请选择: ";
    case 6:
        ClearQueue_Sq(Q);
        cout<<"该循环队列已清空, ";
        break;
    case 7:
        flag=0;
        break;
    }
}
}
=============================================
(C版之基本操作)
队列是先进先出的数据结构，出队的一端叫队首，入队的一端叫队尾，就像是日常生活中排队买火车票一样，下面是队列的基本操作
#include <stdio.h>#include <string.h>#include <stdlib.h>typedef int QElemType;typedef struct QNode{    QElemType data;    struct QNode *next;}QNode,*QueuePtr;typedef struct{    QueuePtr front;    QueuePtr rear;}LinkQueue;int InitQueue(LinkQueue *Q);int DestroyQueue(LinkQueue *Q);int ClearQueue(LinkQueue *Q);int QueueEmpty(LinkQueue Q);int QueueLength(LinkQueue Q);int GetHead(LinkQueue Q,QElemType *e);int InsertQueue(LinkQueue *Q,QElemType e);int DelQueue(LinkQueue *Q,QElemType *e);int PrintQueue(LinkQueue Q);
int InitQueue(LinkQueue *Q){    Q->front = Q->rear = (QueuePtr )malloc(sizeof(QNode));    if(!Q->front)    {        perror("malloc error
");        return -1;    }    Q->front->next = NULL;    Q->front->data = 0;    return 0;}int DestroyQueue(LinkQueue *Q){    while(Q->front)    {        Q->rear = Q->front->next;        free(Q->front);        Q->front = Q->rear;    }    Q = NULL;    return 0;}int ClearQueue(LinkQueue *Q){    return 0;}int QueueEmpty(LinkQueue Q){    if(Q.front == Q.rear)    {        return 1;    }    else    {        return 0;    }}int QueueLength(LinkQueue Q){    return Q.front->data;}int GetHead(LinkQueue Q,QElemType *e){    if(Q.front->next == NULL)    {        perror("Queue is empty!
");        *e = -1;        return -1;    }    *e = Q.front->next->data;    return 0;}int InsertQueue(LinkQueue *Q,QElemType e){    QueuePtr p = (QueuePtr )malloc(sizeof(QNode));    if(p == NULL)    {        perror("malloc error!
");        return -1;    }    p->data = e;    p->next = NULL;    (Q->rear)->next = p;    Q->rear = p;    Q->front->data++;    return 0;}int DelQueue(LinkQueue *Q,QElemType *e){    if(Q->front == Q->rear)    {        perror("The queue is empty!");        return -1;    }    QueuePtr p = (QueuePtr )malloc(sizeof(QNode));    p = Q->front->next;    *e = p->data;    Q->front->next = p->next;    if(Q->rear == p)    {        Q->rear = Q->front;    }    free(p);    Q->front->data--;    return 0;}int PrintQueue(LinkQueue Q){    Q.front = Q.front->next;    while(Q.front != NULL)    {        printf("%d-----",Q.front->data);        Q.front = Q.front->next;    }    return 0;}
=========================================
(C版之基本操作)
1.链式队列
//队列结点结构体
typedef struct QNode
{ QElemType data;
  QNode *next;
}*Queueptr;
------------------------------
//指向结点的指针
struct LinkQueue
{  Queueptr front,rear;
}
<STRONG><SPAN style="COLOR: #000066; FONT-SIZE: 18px">void InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
  if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
    exit(OVERFLOW);
  Q.front->next=NULL;
}

void DestroyQueue(LinkQueue &Q)
{ // 销毁队列Q(无论空否均可)
  while(Q.front)
  {
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;//释放一块内存要做两点：1.释放指向它的指针。2.将该指针指向空
  }
}

void ClearQueue(LinkQueue &Q)
{ // 将Q清为空队列
  QueuePtr p,q;
  Q.rear=Q.front;
  p=Q.front->next;
  Q.front->next=NULL;//只留下头结点
  while(p)
  {
    q=p;
    p=p->next;
    free(q);
  }
}

Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
  if(Q.front->next==NULL)//注意不要把链式队列的判空条件与循环队列混淆
    return TRUE;
  else
    return FALSE;
}

int QueueLength(LinkQueue Q)
{ // 求队列的长度
  int i=0;
  QueuePtr p;
  p=Q.front;
  while(Q.rear!=p)
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetHead(LinkQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  return OK;
}

void EnQueue(LinkQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
  QueuePtr p;
  if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
    exit(OVERFLOW);
  p->data=e;
  p->next=NULL;
  Q.rear->next=p;
  Q.rear=p;
}

Status DeQueue(LinkQueue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  Q.front->next=p->next;
  if(Q.rear==p)
    Q.rear=Q.front;//如果只有一个节点，那么删除这个节点后rear指针也就丢了，需重新赋值
  free(p);
  return OK;
}

void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
  QueuePtr p;
  p=Q.front->next;
  while(p)
  {
    vi(p->data);
    p=p->next;
  }
  printf("
");
}</SPAN></STRONG>
<strong><span style="font-size:18px;color:#000066;">void InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
  if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
    exit(OVERFLOW);
  Q.front->next=NULL;
}

void DestroyQueue(LinkQueue &Q)
{ // 销毁队列Q(无论空否均可)
  while(Q.front)
  {
    Q.rear=Q.front->next;
    free(Q.front);
    Q.front=Q.rear;//释放一块内存要做两点：1.释放指向它的指针。2.将该指针指向空
  }
}

void ClearQueue(LinkQueue &Q)
{ // 将Q清为空队列
  QueuePtr p,q;
  Q.rear=Q.front;
  p=Q.front->next;
  Q.front->next=NULL;//只留下头结点
  while(p)
  {
    q=p;
    p=p->next;
    free(q);
  }
}

Status QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
  if(Q.front->next==NULL)//注意不要把链式队列的判空条件与循环队列混淆
    return TRUE;
  else
    return FALSE;
}

int QueueLength(LinkQueue Q)
{ // 求队列的长度
  int i=0;
  QueuePtr p;
  p=Q.front;
  while(Q.rear!=p)
  {
    i++;
    p=p->next;
  }
  return i;
}

Status GetHead(LinkQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  return OK;
}

void EnQueue(LinkQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
  QueuePtr p;
  if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败
    exit(OVERFLOW);
  p->data=e;
  p->next=NULL;
  Q.rear->next=p;
  Q.rear=p;
}

Status DeQueue(LinkQueue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
  QueuePtr p;
  if(Q.front==Q.rear)
    return ERROR;
  p=Q.front->next;
  e=p->data;
  Q.front->next=p->next;
  if(Q.rear==p)
    Q.rear=Q.front;//如果只有一个节点，那么删除这个节点后rear指针也就丢了，需重新赋值
  free(p);
  return OK;
}

void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
  QueuePtr p;
  p=Q.front->next;
  while(p)
  {
    vi(p->data);
    p=p->next;
  }
  printf("
");
}</span></strong>
2.顺序队列---循环队列
性质如下:
1.头指针指向对头元素，尾指针指向队尾的下一个位置。(这里的指针都是为指针，实际是数组序号)
2.为了区分队满与对空，则定义一个存储空间为MAX_QSIZE大小的队列只允许存放MAX_QSIZE-1个数据。
3.判空条件为:if(Q.front ==Q.rear) return true;
   判满条件为:if((Q.rear+1)%MAX_QSIZE==Q.front) return true;
4.循环队列的长度为:(Q.read-Q.front+MAX_SIZE)%MAX_QSIZE
5.当删除对头元素或者在对尾插入元素时指针均需向后移动。操作为:
    Q.rear=(Q.rear+1)%MAX_QSIZE;
    Q.front=(Q.front+1)%MAX_QSIZE;
结构体定义如下:
struct SqQueue
{QElemType *base;//指向开辟的空间的首地址
  int front;
  int rear;
}
void InitQueue(SqQueue &Q)
 { // 构造一个空队列Q
   Q.base=(QElemType *)malloc(MAX_QSIZE*sizeof(QElemType));
   if(!Q.base) // 存储分配失败
     exit(OVERFLOW);
   Q.front=Q.rear=0;
 }

 void DestroyQueue(SqQueue &Q)
 { // 销毁队列Q，Q不再存在
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
 }

 void ClearQueue(SqQueue &Q)
 { // 将Q清为空队列
   Q.front=Q.rear=0;
 }

 Status QueueEmpty(SqQueue Q)
 { // 若队列Q为空队列，则返回TRUE；否则返回FALSE
   if(Q.front==Q.rear) // 队列空的标志
     return TRUE;
   else
     return FALSE;
 }

 int QueueLength(SqQueue Q)
 { // 返回Q的元素个数，即队列的长度
   return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;
 }

 Status GetHead(SqQueue Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];//等价于e=*(Q.base+Q.front)
   return OK;
 }

 Status EnQueue(SqQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素
   if((Q.rear+1)%MAX_QSIZE==Q.front) // 队列满
     return ERROR;
   Q.base[Q.rear]=e;//等价于*(Q.base+Q.rear)=e
   Q.rear=(Q.rear+1)%MAX_QSIZE;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
   if(Q.front==Q.rear) // 队列空
     return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAX_QSIZE;
   return OK;
 }

 void QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi()
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(Q.base[i]);
     i=(i+1)%MAX_QSIZE;
   }
   printf("
");
 }
/*
 * 用数组实现一个两端都能插入和删除操作的双端队列
 */

static const int nLength = 5;
static int deque[nLength];
static int nIdxHead = 0;
static int nIdxTail = 0;

enum Err
{
    NoErr,
    errOverFlow,
    errUnderFlow,
};

// 头进队
Err EnDequeHead(int x)
{
    if (((nIdxHead + nLength - 1) % nLength) == nIdxTail)
        return errOverFlow;
    nIdxHead = ((nIdxHead + nLength - 1) % nLength);
    deque[nIdxHead] = x;
    return NoErr;
}

// 头出队
Err DeDequeHead(int *pX)
{
    if (nIdxHead == nIdxTail)
        return errUnderFlow;
    if (NULL != pX)
        *pX = deque[nIdxHead];
    nIdxHead = (nIdxHead + 1) % nLength;
    return NoErr;
}

// 尾进队
Err EnDequeTail(int x)
{
    if (((nIdxTail + 1) % nLength) == nIdxHead)
        return errOverFlow;
    deque[nIdxTail] = x;
    nIdxTail = ((nIdxTail + 1) % nLength);
    return NoErr;
}

// 尾出队
Err DeDequeTail(int *pX)
{
    if (nIdxHead == nIdxTail)
        return errUnderFlow;
    nIdxTail = (nIdxTail + nLength - 1) % nLength;
    if (NULL != pX)
        *pX = deque[nIdxTail];
    return NoErr;
}