精华内容
下载资源
问答
  • 链表循环队列程序

    2018-05-23 13:36:15
    链表循环队列简单的C语言程序供初学者参考,希望有用。
  • C语言实现 循环链表实现队列

    多人点赞 2021-03-18 21:40:24
    C语言实现 循环链表实现队列 #include <stdio.h> #include "stdlib.h" typedef struct queuenode{ int data; struct queuenode * next; }QueueNode; typedef struct { QueueNode * rear; }...

    C语言实现 循环链表实现队列

      • #include <stdio.h>
        #include "stdlib.h"
        typedef struct  queuenode{
        	int data;
        	struct queuenode * next;
        	
        }QueueNode;
        typedef  struct {
        	QueueNode * rear;
        	
        }linkQueue;
        void insertNode(linkQueue *Q,int x){
        	QueueNode * p = malloc(sizeof(QueueNode));
        	p->data = x;
        	p ->next = Q ->rear ->next;
        	Q->rear ->next  = p;
        	Q ->rear = p;
        	
        }
        int emptyQueue(linkQueue *Q){
        	return Q->rear ->next->next == Q->rear->next;
        }
        linkQueue * initQueue(void){
        	linkQueue * L = malloc(sizeof(linkQueue));
        	QueueNode * node = malloc(sizeof(QueueNode));
        	//注意malloc一个node然后再让link的指向
        	L->rear = node;
        	L->rear->next = L->rear;//指向自己
        	return L;
        }
        void printqueue(linkQueue * Q){
        	QueueNode *p;
        	p = Q->rear ->next->next;
        	//从节点开始遍历,p=p->next 指向,那个表头节点空节点时,刚好遍历完最后一个标为节点,rear,所以应该在rear->next时候停下
        	while (p!=Q->rear->next) {
        		printf("%d ",p->data);
        		p=p->next;
        	}
        	
        }
        int deleteQueue(linkQueue *Q){
        	QueueNode *p;
        	p = Q ->rear ->next->next;
        	//先判空,然后从表头删除,指向表头节点的位置
        	if(emptyQueue(Q)){
        		printf("link NULL");
        		return -1;
        	}
        	int x = p->data;
        	
        	if(p == Q->rear){
        		//最后一个节点
        		//要移动指针和rear的位置,使rear的位置停留在表头节点(空节点),指向也好指向自己
        		Q->rear = Q ->rear->next;
        		Q->rear->next = Q->rear;
        	}else {
        		Q ->rear ->next->next = p->next;
        		//改变指向,确定了新的头节点
        	}
        	
        	free(p);
        	return x;
        }
        int main(int argc, char *argv[]) {
        	linkQueue * Q;
        	Q = initQueue();
        	insertNode(Q, 1);
        	insertNode(Q, 2);
        	insertNode(Q, 3);
        	deleteQueue(Q);
        	printqueue(Q);
        }
        
      • 插入结构

      • 代码注意点,首先是初始化,和整体的循环链表,循环链表因为首位相连,可以在O(1)时间访问头节点和尾巴节点,选用头节点要找尾节点就要遍历整个链表,选用尾节点作为链表的开始就可以轻易的找到头节点

      • 尾节点和头节点之间有一个不存储数据的节点,这个概念能方便在“表头节点”,就是图中标记null节点的左边或右边进行插入和删除,向下图的四个图一样,中间的“表头节点”这个概念节点是不存储数据的,rear和head中间隔开了一个表头节点,队列在head删除,在rear后插入
        1

    展开全文
  • 假设front指向队列的头部,rear指向队列的尾部。 则队列满的条件是:(rear+1)%QueueSize==front 则队列为空的条件为:rear==...则队列的数组实现如下: private int[] array; private int front; private int rea...

    假设front指向队列的头部,rear指向队列的尾部。

    • 则队列满的条件是:(rear+1)%QueueSize==front
    • 则队列为空的条件为:rear==front
    • 通用的计算队列长度的公式:(rear-front+QueueSize)%QueueSize

    则队列的数组实现如下:

    private int[] array;
    private int front;
    private int rear;
    
    public MyQueue(int capacity){
    	this.array=new int[capacity];
    }
    /**
    *入队
    */
    
    public void enQueue(int element)throws Exception{
    	if((rear+1)%array.length==front){
    		throw new Exception("队列已满");
    	}
    	array[rear]=element;
    	rear=(rear+1)%array.length;
    }
    
    /**
    *出队
    */
    public int deQueue()throws Exception{
    	if(rear==front){
    		throw new Exception("队列已空");
    	}
    	int deQueueElement=array[front];
    	front=(front+1)%array.length;
    	return deQueueElement;
    }
    

    由于链表不用像数组那样考虑容量问题,所以我们队列的链表实现就像单链表一样,只不过它只能尾进头出而已,我们把它简称为链队列。

    public class LinkQueue {
        /**
         * 结点类
         */
        class Entry{
            int data;
            Entry next;
            public Entry(){
                data=-1;
                next=null;
            }
            public Entry(int data)
            {
                this.data=data;
                this.next=null;
            }
        }
    
        /***定义头尾索引***/
        public  Entry front=null;
        public  Entry rear=null;
        public  int useSize=0;
    
        /****判断队列是否为空****/
        public boolean isEmpty(){
            return useSize==0;
        }
        /*****入队*****/
        public void enQueue(int data){
            //若此时队列为空,则直接插入,头尾索引指向该结点
            if(isEmpty()==true){
                rear=new Entry(data);
                front=rear;
            }
            else {
                //若队列不为空,则尾索引后移
                rear.next=new Entry(data);
                rear=rear.next;
            }
            useSize++;
        }
    
        /****出队*****/
        public int deQueue() throws Exception{
            if(isEmpty()){
                throw new Exception("队列已空");
            }
            int deQueueElement=front.data;
            front=front.next;
            useSize--;
            return deQueueElement;
        }
    
        /****队列遍历输出***/
        public void output(){
            Entry cur=front;
            while (cur!=null){
                System.out.println(cur.data);
                cur=cur.next;
            }
            System.out.println();
        }
    
        public static void main(String[] args) {
            // 动态制作一个链式队列
            LinkQueue link = new LinkQueue();
            for (int x = 0; x < 5; x++) {
                link.enQueue(x);
            }
            System.out.print("队列里的元素是:");
            link.output();
            System.out.println("队列长度是 :" + link.useSize);
            System.out.println("==================");
            try {
                link.deQueue();
            }catch (Exception e) {
                System.out.println("队列为空,不能出队");
            }
            System.out.print("执行一次出队操作后队列里的元素是:");
            link.output();
            System.out.println("执行一次出队操作后队列长度是 :" + link.useSize);
    
        }
    }
    
    
    展开全文
  • 头尾指针以及队列元素之间的关系不变,只是在循环队列中,头尾指针“依环状增 1”的操作可用”模“运算来实现。通过取模运算,头指针和尾指针就可以在顺序表空间内以头尾衔接的方式循环移动。 队空条件:Q.front ==...

    循环队列

    循环队列是将顺序队列变为一个变成一个环状的空间。头尾指针以及队列元素之间的关系不变,只是在循环队列中,头尾指针“依环状增 1”的操作可用”模“运算来实现。通过取模运算,头指针和尾指针就可以在顺序表空间内以头尾衔接的方式循环移动。

    队空条件:Q.front == Q.rear

    队满条件:(Q.rear + 1)% MAXQSIZE == Q.rear(少用一个元素空间,即队列空间为m时,有m-1个元素就认为是队满)。

    循环队列(顺序表实现)

    #include <bits/stdc++.h>
    #define MAXQSIZE 100 ///队列可能到达的最大长度
    #define OK 1
    #define ERROR 0
    using namespace std;
    
    typedef int QElemType;
    typedef int Status;
    typedef struct
    {
        QElemType *base; ///存储空间的基地址
        int front; ///头指针
        int rear; ///尾指针
    }SqQueue;
    
    Status InitQueue(SqQueue &Q) ///循环队列的初始化
    {
        Q.base = new QElemType[MAXQSIZE]; ///为队列分配一个最大容量为MAXQSIZE的数组空间
        if(!Q.base) exit(OVERFLOW); ///存储内存失败
        Q.front = Q.rear = 0; ///头指针和尾指针置为0,队列为空
        return OK;
    }
    
    int QueueLength(SqQueue Q) ///循环队列的长度
    {///返回Q的元素个数,即队列的长度
        return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
    }
    
    Status EnQueue(SqQueue &Q, QElemType e) ///队列入队
    {///插入元素e为Q的新的队尾元素
        if( (Q.rear+1)%MAXQSIZE == Q.front) return ERROR; ///尾指针在循环意义上加一等于头指针,表明队满
        Q.base[Q.rear] = e; ///新元素插入队尾
        Q.rear = (Q.rear+1)%MAXQSIZE; ///队尾指针加1
        return OK;
    }
    
    Status DeQueue(SqQueue &Q, QElemType &e) ///循环队列的出队
    {///删除Q的队头元素,用e返回其值
        if(Q.front == Q.rear) return ERROR; ///队空
        e = Q.base[Q.front]; ///保存队头元素
        Q.front = (Q.front+1)%MAXQSIZE; ///队头元素加1
        return OK;
    }
    
    QElemType GetHead(SqQueue Q) ///取循环队列的队头元素
    {///返回队列的队头元素,不修改头指针
        if(Q.front != Q.rear) return Q.base[Q.front]; ///队列非空
    }
    void Travel(SqQueue Q) ///遍历队列
    {
        int x = Q.front;
        while(x != Q.rear)
        {
            cout<< Q.base[x] << " ";
            x++;
            x %= MAXQSIZE;
        }
        cout<< endl << endl;
    }
    int main()
    {
        SqQueue Q;
        QElemType e;
        cout<< "1. 建立队列" << endl;
        cout<< "2. 入队" << endl;
        cout<< "3. 出队" << endl;
        cout<< "4. 队头元素" << endl;
        cout<< "5. 队列长度" << endl;
        cout<< "6. 遍历队列" << endl;
        int choose = -1;
        while(choose)
        {
            cout<< "请选择:";
            cin>> choose;
            switch(choose)
            {
                case 1:
                {
                    if(InitQueue(Q)) cout<< "队列建立成功!\n\n";
                    else cout<< "队列建立失败\n\n";
                }
                break;
                case 2:
                {
                    cout<< "请输入入队元素:";
                    cin>>e;
                    if(EnQueue(Q, e)) cout<< "入队成功!\n\n";
                    else cout<< "入队失败!\n\n";
                }
                break;
                case 3:
                {
                    if(DeQueue(Q, e)) cout<< "出队元素为: " << e << endl << endl;
                    else cout<< "出队失败!\n\n";
                }
                break;
                case 4:
                {
                    if(Q.front == Q.rear) cout<< "队列为空!\n\n";
                    else cout<< "队头元素为:" << GetHead(Q) << endl << endl;
                }
                break;
                case 5:
                {
                    cout<< "队列长度为:" << QueueLength(Q) << endl << endl;
                }
                break;
                case 6:
                {
                    Travel(Q);
                }
            }
        }
        return 0;
    }
    

    循环队列(链表实现) 

    用带有头结点的单链表存储结构实现队列。 

    #include <bits/stdc++.h>
    #define OK 1
    #define ERROR -1
    using namespace std;
    typedef long long ll;
    typedef unsigned long long ull;
    typedef int Status;
    typedef int QElemType;
    typedef struct QNode ///队列的存储结构
    {
        QElemType data;
        struct QNode *next;
    }QNode, *QueuePtr;
    typedef struct
    {
        QueuePtr front; /// 队头指针
        QueuePtr rear; /// 队尾指针
    }LinkQueue;
    QueuePtr p;
    int length = 0;
    Status InitQueue(LinkQueue &Q) ///构造一个空队列
    {
        Q.front = Q.rear = new QNode; ///生成新结点作为头结点,队头和队尾指针都指向此节点
        Q.front -> next = NULL; ///头结点指针置为空域
        length = 0;
        return OK;
    }
    
    Status EnQueue(LinkQueue &Q, QElemType e) ///插入元素e为Q的新的队尾元素
    {///和顺序循环队列入队操作不同的是,链队在入队前不需要判断队是否满,而是需要为入队
     ///元素分配一个结点空间
        p = new QNode; ///为入队元素分配结点空间,用指针p指向
        p->data = e; ///将新结点数据域置为e
        p->next = NULL; Q.rear->next = p; ///将新结点插入到队尾
        Q.rear = p; ///修改队尾指针
        length++;
        return OK;
    }
    Status DeQueue(LinkQueue &Q, QElemType &e) ///删除Q的队头元素,用e返回其值
    {
        if(Q.front == Q.rear) return ERROR; /// 若队列为空,返回ERROR
        p = Q.front->next;  /// p指向队头元素
        e = p->data; ///e保存队头元素的值
        Q.front->next = p->next; ///修改头结点的指针域
        if(Q.rear == p) Q.rear = Q.front; ///最后一个元素被删,队尾指针指向头结点
        delete p; ///释放原头元素的空间
        length--;
        return OK;
    }
    QElemType GetHead(LinkQueue Q) ///返回Q的队头元素,不修改队头指针
    {
        if(Q.front != Q.rear) return Q.front->next->data; ///返回队头元素的值,队头指针不变
    }
    void Travel(LinkQueue Q)
    {
        if(Q.front == Q.rear) return ;
        p = Q.front->next;
        while(1)
        {
            cout<< p->data << " ";
            if(p==Q.rear) break;
            p = p->next;
        }
        cout<< endl << endl;
    }
    int main()
    {
        LinkQueue Q;
        QElemType e;
        cout<< "1. 建立队列" << endl;
        cout<< "2. 入队" << endl;
        cout<< "3. 出队" << endl;
        cout<< "4. 队头元素" << endl;
        cout<< "5. 队列长度" << endl;
        cout<< "6. 遍历队列" << endl;
        int choose = -1;
        while(choose)
        {
            cout<< "请选择:";
            cin>> choose;
            switch(choose)
            {
                case 1:
                {
                    if(InitQueue(Q)) cout<< "队列建立成功!\n\n";
                    else cout<< "队列建立失败\n\n";
                }
                break;
                case 2:
                {
                    cout<< "请输入入队元素:";
                    cin>>e;
                    if(EnQueue(Q, e)) cout<< "入队成功!\n\n";
                    else cout<< "入队失败!\n\n";
                }
                break;
                case 3:
                {
                    if(DeQueue(Q, e)) cout<< "出队元素为: " << e << endl << endl;
                    else cout<< "出队失败!\n\n";
                }
                break;
                case 4:
                {
                    if(Q.front == Q.rear) cout<< "队列为空!\n\n";
                    else cout<< "队头元素为:" << GetHead(Q) << endl << endl;
                }
                break;
                case 5:
                {
                    cout<< "队列长度为:" << length << endl << endl;
                }
                break;
                case 6:
                {
                    Travel(Q);
                }
            }
        }
        return 0;
    }
    

     

    展开全文
  • 循环链表实现队列操作 讲解详细 通过多次编译 可以运行的
  • 第二,大家在很多书上看到的是使用单链表实现队列,我这里将会使用带头结点尾结点的非循环链表实现,虽然多维护了两个节点和指针域,但是在链表头尾进行插入删除的时候不需要遍历链表了,队列操作变得非常
  • 对于队列来说,从队尾进,队尾出,要设置一个结点类型的指针q->front,和q->rear,q->front指向的结点是一个特殊的结点,不存放值,next指针域指向的是第一个有效的结点,实际上就是队首结点,而q->rear...

    对于队列来说,从队尾进,队尾出,要设置一个结点类型的指针q->front,和q->rear,q->front指向的结点是一个特殊的结点,不存放值,next指针域指向的是第一个有效的结点,实际上就是队首结点,而q->rear开始时与q->front相同,随着不断的入列,永远指向最后一个有效结点,q->rear->next为NULL,其它结点的next域不为NULL。

    LinkNode p = (LinkNode)malloc(sizeof(NODE));

    之所以要对指针类型的p进行malloc是因为仅有指针实际上没有在内存中开辟空间,所以要用malloc为指针指向的结点进行实际内存的分配,而如果是NODE进行定义则不需分配在定义时就完成了分配。在删除结点时,要进行free并且防止野指针:

    free(p);
    p = NULL;

    向下面演示简单的代码,有队列的初始化,判断队列是否为空,入队和出队的操作:

    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    
    typedef struct Node {
    	int val;
    	Node *next;
    }NODE, *LinkNode;
    
    typedef struct QNode {
    	LinkNode front, rear;
    }Queue, *LinkQueue;
    
    void InitQueue(LinkQueue queue)
    {
    	queue->front = queue->rear = (LinkNode)malloc(sizeof(NODE));
    	if (!queue->front)
    		printf("error!\n");
    	queue->front->next = NULL;
    }
    
    bool IsEmpty(LinkQueue queue)
    {
    	if (queue->front == queue->rear)
    		return true;
    	else
    		return false;
    }
    
    void EnQueue(LinkQueue queue, int value)
    {
    	LinkNode p = (LinkNode)malloc(sizeof(NODE));
    	if (!p)
    		printf("error!\n");
    	p->val = value;
    	p->next = NULL;
    	queue->rear->next = p;
    	queue->rear = p;
    }
    //头结点next域指向第一个有效结点
    void DeQueue(LinkQueue queue)
    {
    	if (IsEmpty(queue))
    	{
    		printf("error!队列为空");
    	}
    	LinkNode p = queue->front->next;
    	queue->front->next = p->next;
    	if (queue->rear == p)
    		queue->front = queue->rear;	//当只有一个结点时,p->next为NULL
    	free(p);
    	p = NULL;
    }
    
    void Traverse(LinkQueue queue)
    {
    	if (IsEmpty(queue))
    	{
    		printf("error!队列为空");
    		exit(0);
    	}
    	printf("遍历队列的结果是: ");
    	LinkNode p = queue->front->next;
    	while (p != NULL)
    	{
    		printf("%d ", p->val);
    		p = p->next;
    	}
    	printf("\n");
    }
    
    int main()
    {
    	Queue queue;
    	InitQueue(&queue);
    	EnQueue(&queue, 1);
    	EnQueue(&queue, 2);
    	EnQueue(&queue, 3);
    	Traverse(&queue);
    	DeQueue(&queue);
    	Traverse(&queue);
    	DeQueue(&queue);
    	DeQueue(&queue);
    	if (IsEmpty(&queue))
    		printf("此时栈为空\n");		
    	return 0;
    }

    输出结果为:

     

    2. 再来介绍一下循环队列,这里的循环队列要有一个front,rear指针,当然这里的指针是名义上的,由于这里的循环队列使用的是顺序结构,就是开辟了一个数组,而不是上面那种链表,所以指针可以用数组下标int类型来表示,要注意的是,初始化循环链表时,q.front 和q.rear = 0相等,但q.front只随着出队前进,q.rear则随着入队前进,q.rear指向的是填有实际元素的结点的下一位,即开辟的MaxSize数组有一个单位不能使用,判断队满的方法就是q.rear的下一位就是q.front,此时q.rear指向的是没有存值的结点,代码为:

     有一个问题时在函数定义时,参数只能用(SqQueue &queue)省去&会报错,这里暂时有点不够理解:

    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    
    #define MaxSize 4 //多一个单元方便判断队满
    
    typedef struct {
    	int Block[4];
    	int front, rear;
    }SqQueue;
    
    
    
    void InitQueue(SqQueue &queue)
    {
    	queue.front = queue.rear = 0;
    }
    
    bool IsEmpty(SqQueue &queue)
    {
    	if (queue.front == queue.rear)
    		return true;
    	else
    		return false;
    }
    
    bool IsFull(SqQueue &queue)
    {
    	if ((queue.rear + 1) % MaxSize == queue.front)
    		return true;
    	else
    		return false;
    }
    
    void EnQueue(SqQueue &queue, int value)
    {
    	if (IsFull(queue))
    	{
    		printf("队满!\n");
    	}
    	else
    	{
    		queue.Block[queue.rear] = value;
    		queue.rear = (queue.rear + 1) % MaxSize;
    	}
    }
    //头结点next域指向第一个有效结点
    void DeQueue(SqQueue &queue)
    {
    	if (IsEmpty(queue))
    	{
    		printf("error!队列为空");
    	}
    	queue.front = (queue.front + 1) % MaxSize;
    }
    
    void Traverse(SqQueue &queue)
    {
    	if (IsEmpty(queue))
    	{
    		printf("error!队列为空");
    		exit(0);
    	}
    	printf("遍历队列的结果是: ");
    	int p = queue.front;
    	while (p != queue.rear)
    	{
    		printf("%d ", queue.Block[p]);
    		p = (p + 1) % MaxSize;
    	}
    	printf("\n");
    }
    
    int main()
    {
    	SqQueue queue;
    	InitQueue(queue);
    	EnQueue(queue, 1);
    	EnQueue(queue, 2);
    	EnQueue(queue, 3);
    	if (IsFull(queue))
    		printf("队满!\n");
    	Traverse(queue);
    	DeQueue(queue);
    	Traverse(queue);
    	EnQueue(queue, 1);
    	Traverse(queue);
    	DeQueue(queue);
    	Traverse(queue);
    	DeQueue(queue);
    	DeQueue(queue);
    	if (IsEmpty(queue))
    		printf("此时队为空\n");
    	return 0;
    }

    运行结果:

     

     

    展开全文
  • 顺序存储(数组)和链式存储(链表),此博文描述的是数组的实现(后续更新链表实现)  代码实现 初始化队列:初始化一个size长度的队列队列的值都为0 判断队列是否已满:队列满,不可插入队列 判断队列是否为空...
  • 循环链表实现队列

    2020-10-27 22:11:55
    数据结构——用循环链表实现队列 实现方式:只是简单的链表插入与链表删除操作 只是构造与析构时略有差别,注意循环结束时的判断,可以判断两个指针是否相遇,或者将链表改造成普通链表 /* 设以不带头结点的循环...
  • 1. 基于数组实现循环队列 package com.feifei.demo.queue; import java.io.Serializable; import java.util.Objects; import java.util.stream.Stream; /** * 自定义循环队列 * 1. 单队列会出现假溢出的情况,...
  • 循环链表实现循环队列

    千次阅读 2016-04-27 11:50:39
    #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; #define MAXQSIZE 100 //q.rear+1=q.front则...//头指针,指向首元素,直接用下标指向链表空间,因此循环队列是基于数组实现的 int rear;//尾指针,指向最后一个元...
  • 数据结构篇:循环队列的C语言实现及其基本操作 #简述 循环队列在有些嵌入式软件开发中使用频繁,同时队列是非常重要的数据结构。 #include<stdio.h> #include<stdlib.h> #define Maxsize 20 //队列达到...
  • /* end指向队列尾,若队列空则指向head*/ int g_queue[MAX_QUEUE + 1] = {0}; unsigned int g_queueHead = 1; unsigned int g_guard = 0; unsigned int g_queueEnd = 1; int enqueue(int i) { if(queue_full()) {...
  • 1.单链表实现队列 # -*- coding:utf-8 -*- class LinkedQueue: class Node: def __init__(self,element,next): self.element = element self.next = next #创建一个空队列 def __init__(self): ...
  • 循环链表实现队列 队首位于单链表的头结点处,队尾位于单链表的尾结点处,尾结点的指针域指向头结点;维护尾指针和链表长度;当加入元素时,依据尾指针在尾结点后添加新元素,取出元素时候依据尾指针,取出尾结点...
  • C++循环队列实现模型

    2021-01-20 05:48:31
    本文实例讲述了C++循环队列实现模型。分享给大家供大家参考。具体分析如下: 前段时间在知乎上看到这样一个小题目: 用基本类型实现一队列,队列要求size是预先定义好的的。而且要求不可以使用语言自带的api,如C++...
  • 内容索引:VC/C++源码,游戏编程,贪吃蛇 又一个贪吃蛇i游戏的源码,虽然每一款贪吃蛇的玩法都相同,但是编程的算法却不同,本贪吃蛇有要是应用到VC++的循环队列和简单链表原理实现的,用键盘上的W/A/S/D键分别控制...
  • 运用了类和对象的思想,在控制台上运行,按上下左右方向键控制方向。j
  • 循环队列-链表实现

    千次阅读 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; ...
  • C语言数据结构链表队列实现 1.写在前面  队列是一种和栈相反的,遵循先进先出原则的线性表。  本代码是严蔚敏教授的数据结构书上面的伪代码的C语言实现代码。  分解代码没有包含在内的代码如下: #include #...
  • 实现 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <...
  • 链表实现循环队列的基本功能

    千次阅读 2018-10-15 22:30:55
    链表实现循环队列的插入(入队)、删除(出队)和遍历。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define ERROR 0 typedef int Status; typedef int QElemType; typedef ...
  • c语言实现循环队列和链式队列

    千次阅读 2017-08-24 19:00:49
    队列与栈不同,队列必须是先进先出(first in first out),而栈是后进先出的(last ...循环队列采用牺牲一个存储单元的方法。 front = rear表示队列空 (rear + 1) % MaxSize = front表示队列满 例如: rear = 4 fron
  • 队列的特征就是“先入先出”,入队时在链表的尾部插入数据,出队时删除掉头节点后面的节点,需要一个尾指针,始终指向链表的尾部(新加进来的节点)。具体请看原理图: 代码实现 #include <stdio.h> #include...
  • Java实现队列的两种方式(链表,循环数组)数组实现循环队列1、需要一个theSize变量,来判断队列是否填满了数组,或者判断队列是否为空代码如下public class cycleQueue { private int front ;//队头 private int ...
  • 一、什么是队列: ... 队列的实现方式数组实现、链表实现三、常见的队列:  常用队列循环队列、阻塞队列、并发队列 四、怎么实现一个无BUG的队列思考  思考1:head(头元素)和tail(尾元素)的初始值 ...
  • 循环链表实现的链式队列,只设头指针,不设尾指针#include "LLQueue.h"int main() { LLQueue lq; QueueInit(&lq); for (int i = 0; i ; i++) { QueueAppend(&lq, i + 1); printf("%d 入队列\n", i + 1);

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,119
精华内容 44,047
关键字:

循环队列链表实现