队列之链表实现

#include<iostream>
using namespace std;
struct LinkQueueNode
{
     LinkQueueNode* nextIn;
     int value;
};

struct LinkQueue
{
    LinkQueueNode* front;
    LinkQueueNode* rear;
    bool isEmpty;
    int cnt;
};

LinkQueue* createLinkQueue()
{
    LinkQueueNode* head = (LinkQueueNode* )malloc(sizeof(LinkQueueNode));
    LinkQueue* link =(LinkQueue*)malloc(sizeof(LinkQueue));
    link->front=head;
    link->rear=head;
    link->isEmpty=true;
    link->cnt=0;
    return link;
}
void InQueue(LinkQueue* q, int value)
{
    LinkQueueNode* newIn = (LinkQueueNode* )malloc(sizeof(LinkQueueNode));
    newIn->nextIn=NULL;
    newIn->value=value;
    q->rear->nextIn=newIn;
    q->rear=newIn;
    q->isEmpty=((++q->cnt)==0);
}
bool Dequeue(LinkQueue* q, int* value)
{
    if(!q->isEmpty)
    {
        LinkQueueNode* tep = q->front->nextIn;
        *value = tep->value;
        q->front->nextIn=tep->nextIn;
        q->isEmpty=((--q->cnt)==0);
        if(q->isEmpty)
            q->rear=q->front;///当清空的时候,要重新设置rear
        delete tep;
        return 1;
    }
    return 0;
}
bool front(LinkQueue* q, int* value)
{
    if(!q->isEmpty)
    {
        LinkQueueNode* tep = q->front->nextIn;
        *value = tep->value;
        return 1;
    }
    return 0;
}
void outPut(LinkQueue* q)
{
    LinkQueueNode* p = q->front->nextIn;
    while(p!=NULL)
    {
        cout<<p->value<<" ";
        p=p->nextIn;
    }
    cout<<endl;
}
void clearLinkQueue(LinkQueue* q)
{
    int x;
    while(!q->isEmpty)
    {
         Dequeue(q,&x);
         cout<<x<<" ";
    }
    cout<<endl;
}
void main()
{
    int len=10;
    LinkQueue* q = createLinkQueue();
    int v;
    for(int i=0;i<len;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         InQueue(q,v);

    }
    cout<<endl;
    outPut(q);
    clearLinkQueue(q);

    for(int i=0;i<len;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         InQueue(q,v);

    }
    cout<<endl;
    outPut(q);

    Dequeue(q,&v);
    cout<<v<<endl;
    outPut(q);

    front(q,&v);
    cout<<v<<endl;
    outPut(q);

    Dequeue(q,&v);
    cout<<v<<endl;
    outPut(q);

    Dequeue(q,&v);
    cout<<v<<endl;
    outPut(q);

    for(int i=0;i<5;i++)
    {
         v = rand() % 100;
         cout<<v<<" ";
         InQueue(q,v);

    }
    cout<<endl;
    outPut(q);
    if(!front(q,&v))
        cout<<"fail"<<endl;
    else outPut(q);

    clearLinkQueue(q);

    if(!front(q,&v))
        cout<<"fail"<<endl;
    else outPut(q);

    if(!front(q,&v))
        cout<<"fail"<<endl;
    else outPut(q);

    cin>>len;
}
时间: 2024-08-07 04:09:01

队列之链表实现的相关文章

洛谷P1160 队列安排 链表

洛谷P1160 队列安排   链表 1 #include <cstdio> 2 #include <cstring> 3 #include <cmath> 4 #include <cstdlib> 5 #include <string> 6 #include <algorithm> 7 #include <iomanip> 8 #include <iostream> 9 using namespace std

队列(二)——队列的链表实现方式

1.队列的单向链表的实现方法 return只可以返回一个值,单向循环链表来实现队列的时候可以只保留一个指针,因为保留rear指针能够很方便的表示出front指针,所以保留rear指针. 另外由于链表的第一个结点处理比较特殊,所以在初始化的时候需要单独处理.链表实现的队列思想也是第一个单元作为头结点,不存放数据,rear指针指向的总是尾结点(在循环链表中也就是头结点的上一个结点). 2.实现方法 用带表头的单向循环链表来实现 #include <stdio.h> #include <mal

《啊哈算法》——栈、队列、链表

通过题目我们可以看出这篇文章将介绍什么,栈.队列.链表本质上是数据结构中的东西,通过这章的学习能够给今后数据结构的学习打下一点基础. 队列: 我们通过一个简单的谜题来引入队列的概念,给出一串9位的加密QQ号,对于这串数字,删除第一位数字,然后将第二位数字放到这串数字的最后.反复操作,直到这一串数字的所有数字都被删除.在这个过程中,按照数字删除先后顺序排列的9位数字的便是解密后的QQ号,请问解密后的QQ号是多少? 其实从数学原理的角度,这个问题并没有什么难度,非常好理解,但关键在于,如何通过程序来

算法(4)—— 队列的链表实现

1. 队列的链表实现EnQueue 在尾节点,DeQueue 在首节点. 1 #include "fatal.h" 2 3 typedef int ElementType ; 4 typedef struct QueueNode * Queue; 5 typedef struct QueueNode * Position; 6 7 #define MAXSIZE (6) 8 9 10 struct QueueNode { 11 ElementType data; 12 Position

算法导论第十章 栈队列和链表

本章讲述的是基本的数据结构,如栈.队列和链表.这些都是最最基本的数据结构,具体的就不再啰嗦.然后本章也没有什么需要特别注意的点,哦,有一个小节:指针和对象的实现,可以认真看一下,大概就是用其他的实现方式来代替指针和对象的实现,因为有些语言不支持指针和对象数据类型,那在实现这种链式的数据结构就无法表示,本节介绍的方法就是利用数组和数组下标来构造对象和指针,说白了,就是利用数组来表示链式对象.个人感觉意义不大,权当了解得了. 结合一些常见的笔试面试题,我就用3个习题来总结这一章吧. 1.习题10.1

数组队列 与 链表队列

做了些实验,感觉 用链表实现队列 比 用数组实现队列 性能好 进出队的每秒操作数比较 数组队列 enqueue 37,037 dequeue 4,166,666 链表队列 enqueue 277,778 dequeue 666,667 先入队n次,再出队n次的运行时间比较,单位是秒 出入队次数 | 数组队列运行时间 | 链表队列运行时间 1,000 0.01 0.01 10,000 0.04 0.04 100,000 2.7 0.4 1,000,000 4 最后一组,数组队列的半天没运行出来 下

FIFO 队列的链表和数组实现

FIFO (First-in, First-out,先进先出)队列:当执行delete操作时删除那些呆在队列中时间最长的元素. FIFO 队列是这样一个ADT,包含两个基本操作:插入(put)一个新的项.删除(get)一个最早插入的项. 一.FIFO队列的链表实现 FIFO 队列和下堆栈的区别在于新项的插入是在尾部,而不是在头部.因此实现程序要保存一个指向链表最后一个节点的尾指针tail ,因此当Put操作时,将tail 指针指向的next 指向新节点,然后更新tail指针,让它指向那个新的节点

最全C 语言常用算法详解-排序-队列-堆栈-链表-递归-树

具体 源代码 案例查看github,持续更新中............ github地址:https://github.com/Master-fd/C-Algorithm 1. 二分法查找 2. 冒泡排序 3. 插入排序 4. 希尔排序 5. 选择排序 6. 快速排序 7. 单链表实现堆栈 8. 单链表实现队列 9. 普通单链表 10. 递归实现斐波拉契数列 11. 递归实现strlen 12. 循环链表 13. 求素数 14. 双向链表 15. 顺序表实现队列 16. 顺序表实现栈 17. 顺

第二章、栈、队列、链表

第一节.解密QQ号——队列p29 解密QQ号——队列 #include <stdio.h> int main() { int q[102]={0,6,3,1,7,5,8,9,2,4},head,tail; //int i; //初始化队列 head=1; tail=10; //队列中已经有9个元素了,tail执向的队尾的后一个位置 while(head<tail) //当队列不为空的时候执行循环 { //打印队首并将队首出队 printf("%d ",q[head])

队列的链表方式实现

1.像堆栈一样,也可以使用链表来实现一个队列.此时需要两个变量 f r o n t和r e a r来分别跟踪队列的两端,这时有两种可能的情形:从 f r o n t开始链接到 r e a r(如a所示)或从 r e a r开始链接到f r o n t(如图 b所示) .不同的链接方向将使添加和删除操作的难易程度有所不同.图 6 - 8和6 - 9分别演示了添加元素和删除元素的过程.可以看到,两种链接方向都很适合于添加操作,而从f r o n t到r e a r的链接更便于删除操作的执行.因此,我