数据结构 链队列与循环队列 C

**

队列(quenue)

**
只允许在一段进行插入操作，在另一端进行删除操作的线性表，
先进先出
例：输入缓冲区接受键盘的输入按队列形式输入输出
队列一般用链表实现，称为链队列

typedef struct QNode{
   ElemType data;
   struct QNode *next;
}QNode,*QueuePtr; //定义结点结构
typedef struct{
    QueuePtr front,rear;//定义头尾指针 front指向头节点，不存储数据
}LinkQueue;

创建一个队列需要：
1.在内存中创建一个头结点
2.将队列的头尾指针都指向生成的头结点，此时是空队列（初始化阶段)

    initQueue(LinkQueue *q)
{
    q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
    //生成结点，同时将队头尾指针指向这个结点
    if(!q->front)
        exit(0);
    q->front->next=NULL;
}

插入队列
创建一个结点，
rear的下一个元素是这个结点
rear是这个结点

InsertQueue(LinkQueue *q,ElemType e)
{
    QueuePtr p;//声明，定义,生成一个结点
    p=(QueuePtr)malloc(sizeof(QNode));//为结点分配空间
    if(p==NULL)
        exit(0);
    p->data=e;
    p->next=NULL;
    q->rear->next=p;
    q->rear=p;
}

出队列
出队列将队列第一个元素移出，队头指针不发生变化，
改变头结点的next指针即可.
出队列的特殊情况：原队列若只有一个元素，则需处理队尾指针
队列只有一个元素，删除后队列变空队列

DeleteQueue(LinkQueue *q,ElemType *e)
{
    QueuePtr p;
    if(q->front==q->rear)//空队列
        return;
    p=q->front->next;//将p作为第一个结点，则删除p即可
    *e=p->data;//p是一个指针
    q->front->next=p->next;//将第一个结点删除后连接q的头结点和后面的结点
    if(q->rear==p)//队列只有一个元素
        q->rear=q->front;//队列只有一个元素，删除后队列变空队列
        free(p);
}

销毁队列
链队列建立在内存的动态区，
当不用时要及时销毁，
以免过多占用内存空间

DestroyQueue(LinkQueue *q)
{
    while(q->front)
    {
        q->rear=q->front->next;
        free(q->front);
        q->front=q->rear;
    }
}
PrintQueue(LinkQueue *q)
{
    QueuePtr p;
    p=q->front;
    if(q->front==q->rear)
        printf("空队列\n");

    while(p!=q->rear)
    {
        p=p->next;
      printf("%d ",p->data);

    }
}

打印队列

PrintQueue(LinkQueue *q)
{
    QueuePtr p;
    p=q->front;
    if(q->front==q->rear)
        printf("空队列\n");

    while(p!=q->rear)
    {
        p=p->next;
      printf("%d ",p->data);

    }
}

插入判断是否为满且给插入结点分配空间及结点是否不存在，删除判断是否为空且是否只有一个元素

实现过滤字符：

int main()
{
    LinkQueue q;
    initQueue(&q);
    char s[10];
    char c;
    int i=0;
    printf("输入字符\n");
    scanf("%c",&c);
    while(c!='#')
    {
        while(isdigit(c))
        {
             s[i++]=c;//缓冲
        s[i]='\0';
        scanf("%c",&c);
        if(c==' ')
        {
          int d=atoi(s);
             InsertQueue(&q,d);
             i=0;
             break;
        }

        }
        scanf("%c",&c);

    }
        PrintQueue(&q);

        DestroyQueue(&q);

    return 0;
}

实现输入字符，并输出

int main()
{
    LinkQueue q;
    initQueue(&q);
char c;
    printf("输入字符\n");
    scanf("%c",&c);
    while(c!='#')
    {
             InsertQueue(&q,c);
        scanf("%c",&c);

    }
PrintQueue(&q);
        DestroyQueue(&q);

    return 0;
}
//注意ElemType的定义

队列的顺序存储
用数组存储
若使下标为0是队头指针，则出队列效率低
若出队列时使队头指针动，
而本身位置不变则效率提高但会造成假溢出
解决办法：循环队列，头尾相接循环
循环队列逻辑上是环形存储空间，实际上是用顺序表进行模拟
循环队列中，front指向第一个元素，rear指向最后一个元素的下一位置
入队时，front不变，元素进入,rear指向下一个空位置
出队时，rear不变，元素出去，front指向下一个元素
队列满时，rear和front指向同一元素，此时队列满
队列空时，rear和front同样指向同一位置但队列空，无元素
循环队列的实现只需灵活运用front和rear即可
rear和front不断加一，即使超出地址范围，自动从头开始,
可采取取模运算模拟：(实现循环)
(rear+1)%QueueSize
(front+1)%QueueSize

循环队列

#define MAXSIZE 100
typedef struct
{
    ElemType *base;//用指针存放，用于存放内存分配基地址，也可以用数组存放，
                    //用指针存放从堆中获取动态内存更灵活
    int front,rear;

}cycleQueue;

初始化

initQueue(cycleQueue *q)
{
    q->base=(ElemType *)malloc(sizeof(ElemType)*MAXSIZE);
    if(!q->base)
       exit(0);
    q->front=q->rear=0;
}

插入队列：
front不变，元素进入,rear指向下一个空位置，用取模的形式实现循环，
队列满时，头尾指针指向同一元素，rear+1取模与front相等，可画图

insertQueue(cycleQueue *q)
{
  if((q->rear+1)%MAXSIZE==q->front)
    return;//队列满
  q->base[q->rear]=e;//数组模拟,灵活运行数组与指针
  q->rear=(q->rear+1)%MAXSIZE;
}

出队列：
rear不变，元素出去，front指向下一个元素（防止越界同样采用取模形式）

DeleteQueue(cycleQueue *q,ElemType *e)
{
    if(q->front==q->rear)//队列空
    return;
    *e=q->base[q->front];
    q->front=((q->front+)%MAXSIZE);
}