循环队列和链式队列的基本操作1

1，循环队列

队列：FIFO

队列在出出队列时需要移动大量元素，时间复杂度为O(n)，而且还可能发生假溢出；

为了降低时间复杂度。可以使用循环队列。在进队列和出队列时时间复杂度都是O(1)；

typedef int QElemType;
typedef struct
{
    QElemType data[QueueSize];
    int front;//指向队列中第一个元素的指针
    int rear;//指向队尾元素的下一个
}SqQueue;
void EnQueue(SqQueue *Q,QElemType e)//入队
{
    if((Q->rear+1)%QueueSize==Q->front)//队列满时，队列中还有一个空闲单元
    {
        printf("队列已满，无法进队列");
    }else
    {
        Q->data[Q->rear]=e;
        Q->rear=(Q->rear+1)%QueueSize;
    }
}
int DeQueue(SqQueue *Q)
{
    QElemType e;
    if(Q->front==Q->rear)
    {
        printf("队列为空，无法出队列");
    }else
    {
        e=Q->data[Q->front];
        Q->front=(Q->front+1)%QueueSize;
        return e;
    }

}
int CountQueue(SqQueue *Q)
{
    return ((QueueSize-Q->front+Q->rear)%QueueSize);
}
int main()
{
    SqQueue Q;
    Q.front=0;
    Q.rear=0;
    int i,x;
    do
    {
        printf("\n入队列（1）or出队列（2）o r统计队列长度（3）");
        scanf("%d",&i);
        switch(i)
        {
            case 1:printf("输入元素:");
                    scanf("%d",&x);
                    EnQueue(&Q,x);
                    break;
            case 2:printf("出队元素为%d\n",DeQueue(&Q));
                    break;
            case 3:printf("队列长度为：%d",CountQueue(&Q));
                    break;
        }
    }while(i!=4);
    return 0;
}

2.链式队列：

#include <iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;
typedef int QElemType;
typedef  struct QNode//节点结构
{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;
typedef struct//队列的链式结构
{
    QueuePtr front,rear;

}LinkQueue;
void InitLinkQueue(LinkQueue *Q)
{
    QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
    Q->front=p;
    Q->rear=p;
}
void EnQueue(LinkQueue *Q,QElemType e)//入队，在队尾插入
{
    QueuePtr s=(QueuePtr)malloc(sizeof(QNode));
    s->data=e;
    Q->rear->next=s;
    Q->rear=s;
    s->next=NULL;
}
int DeQueue(LinkQueue *Q)
{
    QueuePtr p;
    QElemType e;
    if(Q->front==Q->rear)
    {
        printf("队列为空");
    }else
    {
        p=Q->front->next;
        e=p->data;
        Q->front->next=p->next;

        if(p==Q->rear)//如果链表中除了头结点没有元素，则把rear指向头结点
        {
            Q->rear=Q->front;
        }
        free(p);
    }
    return e;
}
void output(LinkQueue *Q)
{
    QueuePtr p;
    if(Q->front==Q->rear)
    {
         printf("队列为空");
    }
    for(p=Q->front->next;p!=NULL;p=p->next)
    {
        printf("%d ",p->data);
    }
}
int main()
{
    LinkQueue Q;
    InitLinkQueue(&Q);
    int i,x;
    do
    {
        printf("\n入队列（1）or出队列（2）o r输出队列（3）");
        scanf("%d",&i);
        switch(i)
        {
            case 1:printf("输入元素:");
                    scanf("%d",&x);
                    EnQueue(&Q,x);
                    break;
            case 2:printf("出队元素为%d\n",DeQueue(&Q));
                    break;
            case 3:output(&Q);
                    break;
        }
    }while(i!=4);
    return 0;
}

3.两者联系

两者基本操作时间复杂度都是O(1).

如果可以事先确定长度，可以选择循环队列。否则，用链队列