精华内容
下载资源
问答
  • /* 1、在队列中,允许插入的一端叫队尾(rear),允许删除的一端称为队头(front)。 2、队头指针始终指向队列头元素(先出队,后++) ... (rear+1) % MAXQSIZE = front,循环队列满(rear始终指向空...
    /*
        1、在队列中,允许插入的一端叫队尾(rear),允许删除的一端称为队头(front)。
        2、队头指针始终指向队列头元素(先出队,后++)
       	   队尾指针始终指向队列尾元素的下一个位置(先++,后进队)
        3、少用一个元素的空间
    	  front = rear,循环队列空
    	  (rear+1) % MAXQSIZE = front,循环队列满(rear始终指向空)
        4、
    */
    typedef int ElementType;
    
    class queueRecord{
    private:
        int capacity;
        int front;
        int rear;//队尾
        int size;//实际队长(也可用来判断空或满)
        ElementType *pArray;
    public:
        queueRecord(int c=100,int f=0,int r=0,int s=0,ElementType*p=NULL):
            capacity(c),front(f),rear(r),size(s),pArray(p){
                createQueue();
            };//调用createQueue申请数组空间
        ~queueRecord(){};
    
        void createQueue();
        bool isEmpty();
        bool isFull();
        void makeEmpty();
        void disposeQueue();
        void enQueue(ElementType e);
        ElementType getFront();
        void deQueue();
    
    };
    
    void queueRecord::createQueue(){
        pArray = new ElementType[capacity];
    }
    
    bool queueRecord::isEmpty(){
        return front==rear;//return size==0;
    }
    
    bool queueRecord::isFull(){
        return (rear+1)%capacity==front;
    }
    
    void queueRecord::makeEmpty(){
        front=0;
        rear=0;
        size=0;
    }
    
    void queueRecord::disposeQueue(){
        if(!pArray) delete pArray;
    }
    
    void queueRecord::enQueue(ElementType e){
        if(isFull())
            cout<<"full queue!";
        else{
            pArray[rear]=e;
            rear=(rear+1)%capacity;
            size++;
        }
    }
    
    ElementType queueRecord::getFront(){
        return pArray[front];
    }
    
    void queueRecord::deQueue(){
        front=(front+1)%capacity;
    }
    
    #include<cstdlib>
    #include<iostream>
    using namespace std;
    typedef int ElementType;
    
    class Node{
        friend class queueRecord;
    private:
        ElementType data;
        Node* _next;
    public:
        Node(ElementType e=0, Node*p=NULL):data(e),_next(p){}
        ~Node();
    };
    class queueRecord{
    private:
        Node* front;
        Node* rear;//队尾
        int size;//实际队长(也可用来判断空或满)
    public:
        queueRecord();
        ~queueRecord(){};
    
        bool isEmpty();
        void makeEmpty();
        ElementType getFront();
        void enQueue(ElementType e);
        void deQueue();
    };
    
    queueRecord::queueRecord(){
        front = new Node(0,NULL);//front指向头结点且始终不变
        rear = front;
        size = 0;
    }
    
    bool queueRecord::isEmpty(){
        return size==0;//front==rear
    }
    
    void queueRecord::makeEmpty(){
        while(!isEmpty())
            deQueue();
    }
    
    ElementType queueRecord::getFront(){
        if(isEmpty()){
            cout<<"Empty queue!";
            return 0;
        }
        else
            return front->_next->data;
    }
    
    void queueRecord::enQueue(ElementType e){
        Node* newNode = new Node(e,NULL);
        rear->_next =  newNode;
        rear = rear->_next;
        size++;
    }
    
    void queueRecord::deQueue(){
        Node* dele = front->_next;
        front->_next = dele->_next;
        free(dele);
        size--;
    }
    int main(){}

    展开全文
  • 第二,大家在很多书上看到的是使用单链表实现队列,我这里将会使用带头结点尾结点的非循环链表实现,虽然多维护了两个节点和指针域,但是在链表头尾进行插入删除的时候不需要遍历链表了,队列操作变得非常
  • 循环队列链表实现

    2013-06-09 18:10:41
    循环队列链表实现).cpp : 定义控制台应用程序的入口点。 //   #include "stdafx.h" #include using namespace std;   struct d_Queue {  d_Queue *next,*prior;  int data; };   d_Queue *initQueue()//初始...

    // 循环队列(链表实现).cpp : 定义控制台应用程序的入口点。

    //

     

    #include "stdafx.h"

    #include

    using namespace std;

     

    struct d_Queue

    {

       d_Queue *next,*prior;

       int data;

    };

     

    d_Queue *initQueue()//初始化队列

    {

       d_Queue * q = new d_Queue;

       q->prior = q->next = q;//为空时头结点的priornext都指向头结点

       return q;

    }

     

    void enQueue(d_Queue * q,int data)//入队

    {

       d_Queue *s = new d_Queue;

       s->data = data;

       q->prior->next = s;//尾结点next指针指向s

       s->prior =  q->prior;//s结点的prior指针指向之前尾结点

       s->next = q;//snext指针指向指向头结点

       q->prior = s;//头结点的prior指针指向s

    }

     

    void deQueue(d_Queue *q)//出队

    {

       if(q->prior == q)

       {

          cout<<"队列为空,出队失败!"<<endl;

          return;

       }

       d_Queue *s = new d_Queue;

       s = q->next;//这里的程序采用头指针指向头结点的方式,所以这里s表示队头

       cout<<s->data<<"出队"<<endl;

       q->next = s->next;//头结点next指向队头的next指针

       s->next->prior = q;//队头的next指针的prior指针指向头结点

       free(s);//释放队头指针

    }

     

    int _tmain(int argc, _TCHAR* argv[])

    {

      

       d_Queue *q = initQueue();

       enQueue(q,1);

       enQueue(q,2);

       deQueue(q);

       //cout<<q<<endl;

       enQueue(q,3);

       deQueue(q);

       deQueue(q);

       enQueue(q,4);

       deQueue(q);

       return 0;

    }

     

    展开全文
  • 循环队列-链表实现

    千次阅读 2014-05-16 23:05:23
    //插入元素e为队列的新队尾元素 int EnQueue(LinkQueue *Q,int e) {  QueuePtr p;  p=(QueuePtr)malloc(sizeof(QNode));  p->data=e;  p->next=NULL;  Q->rear->next=p;  Q->rear=p; ...
    #include<stdio.h> 
    #include<stdlib.h>
     
    typedef struct QNode
    {
        int data;
        struct QNode *next;
    }QNode,*QueuePtr;
     
    typedef struct
    {
        QueuePtr front;
        QueuePtr rear;
    }LinkQueue; //首位指针
     
    //构造一个空队列
    int InitQueue(LinkQueue *Q)
    {
        Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
        if(!Q->front)
            return 0;
        Q->front->next=NULL;
        return 1;
    }
     
    //销毁队列
    int DestoryQueue(LinkQueue *Q)
    {
        while(Q->front)
        {
            Q->rear=Q->front->next;
            free(Q->front);
            Q->front=Q->rear;
        }
        return 1;
    }
     
     
    //插入元素e为队列的新队尾元素
    int EnQueue(LinkQueue *Q,int e)
    {
        QueuePtr p;
        p=(QueuePtr)malloc(sizeof(QNode));
        p->data=e;
        p->next=NULL;
        Q->rear->next=p;
        Q->rear=p;
        return 1;
    }
     
    //
    int DeQueue(LinkQueue *Q,int *e)
    {
        QueuePtr p;
        if(Q->front == Q->rear)
            return 0;
        p=Q->front->next;
        *e=p->data;
        Q->front->next=p->next;
        if(Q->rear == p)
            Q->rear=Q->front;
        free(p);
        return 1;
    }
     
    int PrintQueue(QNode *Q)
    {
        LinkQueue p;
        p.front = Q;
        while(p.front != p.rear)
        {
            printf("%d\n",Q->data);
            Q = Q->next;
        }
     
    }
    void QueueTraverse(LinkQueue Q)
     {
        QueuePtr p=Q.front->next;
        while(p)
        {
            printf("%d\n",p->data);
            p=p->next;
        }
        printf("\n");
     }
    int main()
    {
        int a[100],i;
        LinkQueue Q;
        InitQueue(&Q);
        for(i=0;i<100;i++)
            EnQueue(&Q,i);
        QueueTraverse(Q);
        DeQueue(&Q,&i);
        DeQueue(&Q,&i);
        QueueTraverse(Q);
     
    }
     

    展开全文
  • #include using namespace std; typedef struct node{ int data;... ///此时循环队列里的元素是 3 2 1 3 cout(Q); cout(Q); //cout(Q); cout(Q); ///应该输出的是 3 2 3 return 0; }
    #include <iostream>
    
    using namespace std;
    
    typedef struct node{
        int data;
        struct node *next;
    }Node,*CycleList;
    
    typedef struct Q{
        CycleList head;
        CycleList front;
        CycleList rear;
    }Queue;
    
    void init_queue(Queue &Q) {            ///初始化队列
        Q.front = new Node;
        Q.head=Q.rear = Q.front;
        Q.front->data=0;
        Q.front->next=NULL;
    }
    
    void insert_front(Queue &Q,int e) {   ///插入到队首
        CycleList p = new Node;
        p->data=e;
        Q.head->next=p;
        p->next=Q.front;
        Q.front=p;
        ///整个过程相当于在头结点和第一个结点间插入了一个结点。然后将头指针移到新插入的结点上。
    }
    
    void insert_rear(Queue &Q,int e) {    ///插入到队尾
        CycleList p = new Node;
        p->data=e;
        p->next=Q.head;
        Q.rear->next=p;
        Q.rear=p;                  ///整个过程相当于在尾结点和头结点间插入了一个结点。然后将尾指针移到新插入的结点上。
    }
    
    int del_front(Queue &Q) {               ///删除队首 (注意跳过头节点) 元素并返回要删除的元素
        if(Q.front==Q.head) Q.front=Q.head->next;
        int e=Q.front->data;
        Q.front=Q.front->next;
        return e;
    }
    
    int del_rear(Queue &Q) {                   /// 删除队尾元素并返回要删除的元素
        if(Q.rear == Q.head) while(Q.rear->next!=Q.head) Q.rear=Q.rear->next;
        int e=Q.rear->data;
        CycleList p=Q.front;
        while(p->next!=Q.rear)  p=p->next;     ///为了找到队尾结点的前一个结点。
        p->next=Q.front;
        Q.rear=p;
        return e;
    }
    
    int main()
    {
        Queue Q;
        init_queue(Q);
        insert_front(Q,1);
        insert_front(Q,2);
        insert_front(Q,3);
        insert_rear(Q,3);
        ///此时循环队列里的元素是   3 2 1 3
        cout<<del_front(Q)<<endl;
        cout<<del_front(Q)<<endl;
        //cout<<del_front(Q)<<endl;
        cout<<del_rear(Q)<<endl;
        ///应该输出的是      3 2 3
        return 0;
    }
    

    展开全文
  • Java实现队列的两种方式(链表,循环数组)数组实现循环队列1、需要一个theSize变量,来判断队列是否填满了数组,或者判断队列是否为空代码如下public class cycleQueue { private int front ;//队头 private int ...
  • 循环链表实现队列

    2020-10-27 22:11:55
    数据结构——用循环链表实现队列 实现方式:只是简单的链表插入与链表删除操作 只是构造与析构时略有差别,注意循环结束时的判断,可以判断两个指针是否相遇,或者将链表改造成普通链表 /* 设以不带头结点的循环...
  • C语言实现 循环链表实现队列 #include <stdio.h> #include "stdlib.h" typedef struct queuenode{ int data; struct queuenode * next; }QueueNode; typedef struct { QueueNode * rear; }...
  • 循环链表实现队列操作 讲解详细 通过多次编译 可以运行的
  • 一、什么是队列: ... 队列的实现方式数组实现、链表实现三、常见的队列:  常用队列循环队列、阻塞队列、并发队列 四、怎么实现一个无BUG的队列思考  思考1:head(头元素)和tail(尾元素)的初始值 ...
  • 首先介绍下非循环队列实现形式,不管用链表还是数组实现,总会有两个变量记录队头和队尾的位置 当头尾都指向了索引0位置时,则代表队列中没有元素。 当进行第一次入队操作后,头指向第一个位置。而尾...
  • 循环链表队列的代码实现 循环数组队列的代码实现
  • 循环链表实现队列

    千次阅读 2016-04-21 18:56:36
    假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(不设头指针),编写相应队列初始化,入队,出队。 #include #define datetype int using namespace std; struct QNode ///声明队列结点类型 ...
  • 一、双向链表(double linked list)是在单链表的每个结点中,再设置一个指向其前驱结点的指针域。双向链表的基本操作与单链表基本一样,除了插入和删除的时候需要更改两个指针变量,需要注意的是修改的顺序很重要,...
  • 链表实现循环队列

    2014-04-09 22:31:51
    struct Node { elem e;...//循环队列 class MyQueue { public: MyQueue():pQueueHead(NULL),pQueueRear(NULL),queueSize(10),queueSizeInc(10){}; ~MyQueue(){destroyMyQueue();}; bool initMyQueue
  • 1.循环链表 #include #include #include /* 1.建立一个具有n个链节点的循环链表 2.确定第一个报数人的位置; 3.不断从链表中删除节点,直到链表为空; */ typedef struct LNode { int data
  • 本文介绍了单向链表的一种特例——单向循环链表,并使用单向循环链表实现队列这种数据结构。
  • 链表实现循环队列,也是写几个常用功能,其实和循环列表大同小异 ,就是它的一个特殊形式而已。 文件"myqueue.h" #include using namespace std; template class My_queue; template class N
  • 什么是队列队列是一种线性的数据结构【线性数据结构:数组、栈、队列】 ...代码实现 Array数组类 package cn.itcats.queue; public class Array&lt;E&gt; { private E[] data; ...
  • 约瑟夫环的队列循环链表实现,实现基本功能
  • 队列先进先出,这里用了顺序...循环队列://顺序存储结构的循环队列 #include using namespace std; #define MAXSIZE 100 typedef struct Qnode *Queue; struct Qnode{ int data[MAXSIZE]; int front; int rear;
  • //带头节点循环队列 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef struct QNode{ int data; struct QNode *next; struct QNode *prior; }QNode; typedef struct DQu....
  • 普通队列与循环队列链表实现单队列实现循环链表 单队列实现 队列的定义就不赘述了,直接上代码把。为了方便使用了无头的链表。插入方式为尾插法。 #include <stdio.h> #include <stdlib.h> #include &...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,892
精华内容 756
关键字:

循环队列链表实现