精华内容
下载资源
问答
  • 运用了类和对象的思想,在控制台上运行,按上下左右方向键控制方向。j
  • 链表循环队列程序

    2018-05-23 13:36:15
    链表循环队列简单的C语言程序供初学者参考,希望有用。
  • 内容索引:VC/C++源码,游戏编程,贪吃蛇 又一个贪吃蛇i游戏的源码,虽然每一款贪吃蛇的玩法都相同,但是编程的算法却不同,本贪吃蛇有要是应用到VC++的循环队列和简单链表原理实现的,用键盘上的W/A/S/D键分别控制...
  • 当我们使用数组的时候创建循环队列是为了节省存储空间,而来到链表中时,每一个节点都是动态申请和释放的,不会造成空间的浪费,所以不需要采用循环队列了。第二,大家在很多书上看到的是使用单链表实现队列,我这里...
  • 数据结构篇:循环队列的C语言实现及其基本操作 #简述 循环队列在有些嵌入式软件开发中使用频繁,同时队列是非常重要的数据结构。 #include<stdio.h> #include<stdlib.h> #define Maxsize 20 //队列达到...

    数据结构篇:循环队列的C语言实现及其基本操作

    #简述
    循环队列在有些嵌入式软件开发中使用频繁,同时队列是非常重要的数据结构。

    #include<stdio.h>
    #include<stdlib.h>
    #define Maxsize 20   //队列达到的最大长度 
    typedef struct {      //循环队列的存储结构 
    	int *base;
    	int front;
    	int rear;
    }SqQueue;
    int initQueue(SqQueue &Q){       //空队列队列初始化 
    	Q.base=(int*)malloc(sizeof(int)*Maxsize);
    	if(!Q.base) return 0;
    	Q.front=0;
    	Q.rear=0;
    	return 1;
    } 
    int EnQueue(SqQueue &Q,int e){   //入队操作 
    	if((Q.rear+1)%Maxsize==Q.front){
    		printf("队满\n");
    	//	return 0;
    	}
    	Q.base[Q.rear]=e;
    	Q.rear=(Q.rear+1)%Maxsize;
    	return 1;
    } 
    int DeQueue(SqQueue &Q,int &e){  //出队操作 
    	if(Q.front==Q.rear){
    		printf("队空\n");
    		return 0;
    	}
    	e=Q.base[Q.front];
    	Q.front=(Q.front+1)%Maxsize;
    	return 1;
    } 
    int gethead(SqQueue Q){        //仅获取对头元素 
    	if(Q.front!=Q.rear){
    		return Q.base[Q.front];
    
    	}
    } 
    int gettail(SqQueue Q){      //仅获取队尾元素 
    	if(Q.front!=Q.rear){
    		return Q.base[Q.rear-1];   //如果想获取队尾元素的话,一定要尾指针减一,因为队尾指针是指向队尾元素的下一个 
    
    	}
    } 
    int main(){
    	int i=0;
    	int outnum=0; //接收出队的数字 
    	SqQueue Q;
    	initQueue(Q);
    	for(i=0;i<12;i++)
    	EnQueue(Q,i);
    	printf("头:%d ",gethead(Q)); 
    	printf("尾:%d ",gettail(Q)); 
    	DeQueue(Q,outnum);
    	printf("出队元素的值:%d",outnum);
    } 
    

    循环队列与循环链表的区别

    两年前刚开始学习的时候总分不太清楚,等去年开始了真正“求”学之后才深入理解和区别。(呐,也想表达一下知识只有自己想学才学的深、学的透)。

    循环队列是队列的顺序表示和实现,它的出现解决了顺序队列中“假溢出”的问题。
    循环链表是线性表中链式表示的一种,用链表实现并首位相接。
    本质上,他们两个是平行的,没有啥关系。但在逻辑上都是环形。

    展开全文
  • 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

    展开全文
  • 循环队列 循环队列是将顺序队列变为一个变成一个环状的空间。头尾指针以及队列元素之间的关系不变,只是在循环队列中,头尾指针“依环状增 1”的操作可用”模“运算来实现。通过取模运算,头指针和尾指针就可以在...

    循环队列

    循环队列是将顺序队列变为一个变成一个环状的空间。头尾指针以及队列元素之间的关系不变,只是在循环队列中,头尾指针“依环状增 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;
    }
    

     

    展开全文
  • 假设front指向队列的头部,rear指向队列的尾部。 则队列满的条件是:(rear+1)%QueueSize==front 则队列为空的条件为:rear==front 通用的计算队列长度的公式:(rear-front+QueueSize)%QueueSize 则队列的数组实现...

    假设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);
    
        }
    }
    
    
    展开全文
  • 对于队列来说,从队尾进,队尾出,要设置一个结点类型的指针q->front,和q->rear,q->front指向的结点是一个特殊的结点,不存放值,next指针域指向的是第一个有效的结点,实际上就是队首结点,而q->rear...
  • 循环队列-链表实现

    千次阅读 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; ...
  • 链表队列和循环队列的基本操作 实验内容 完成以下任务: 数组7 5 3 9 2 4 全部入队列 进行三次出队列 将15 18入队列 输出从队头到的队尾所有元素 分别用链队列、循环队列(最大长度为7 队列的操作比较简单 链表队列...
  • 循环链表实现队列操作 讲解详细 通过多次编译 可以运行的
  • 循环队列和顺序队列  队列的存储实现方式有哪些? 顺序存储(数组)和链式存储(链表),此博文描述的是数组的实现(后续更新链表实现)  代码实现 初始化队列:初始化一个size长度的队列,队列的值都为0 判断队列...
  • 数据结构-单链表模拟实现循环队列(c语言实现)

    多人点赞 热门讨论 2021-10-14 16:25:44
    1.类型声明 typedef struct CQueue { ...测试结果 单链表的模拟实现循环队列的基本操作就分享到这里了,感谢你的浏览。如果对你有帮助的话,可以给赞,顺便点个关注。 下期将发布有关与双向链表的基本操作的文章。
  • 循环链表循环队列

    万次阅读 2017-03-07 14:05:38
    单向循环链表 和普通的链表结构不同,单向循环链表的最后一个节点的指针指向了头结点,也就是和Head指针有相同的引用 和普通链表相比,循环链表不需要头指针,能够从任意位置实现链表遍历 双向循环...
  • 循环链表循环队列,只用一个队尾指针就够了,因为循环链表中队尾节点的下一个节点就是队首节点。 队空条件: 队满条件:不考虑 进队操作:将新的节点插入到队尾,称为队尾节点,然后队尾指针指向这个新的节点...
  • /* 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()) {...
  • #include<iostream> using namespace std; #define MAXQSIZE 100 //q.rear+1=q.front则...//头指针,指向首元素,直接用下标指向链表空间,因此循环队列是基于数组实现的 int rear;//尾指针,指向最后一个元...
  • 循环链表实现队列

    2020-10-27 22:11:55
    数据结构——用循环链表实现队列 实现方式:只是简单的链表插入与链表删除操作 只是构造与析构时略有差别,注意循环结束时的判断,可以判断两个指针是否相遇,或者将链表改造成普通链表 /* 设以不带头结点的循环...
  • 循环链表表示队列

    千次阅读 2021-10-24 11:52:41
    假设以带头结点的循环链表表示列队,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判队空、入队和出队等算法。 该算法使用循环链表表示列队。 在算法中只设一个指向队尾元素的指针...
  • 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),请完成下列任务: 1: 队列初始化,成功返回真,否则返回假:bool init_queue(LinkQueue *LQ); 2: 入队列,成功返回真,...
  • 1. 基于数组实现循环队列 package com.feifei.demo.queue; import java.io.Serializable; import java.util.Objects; import java.util.stream.Stream; /** * 自定义循环队列 * 1. 单队列会出现假溢出的情况,...
  • ●在这个实验中,我们将创建一个更通用的数据结构,称为 deque,是双端队列的缩写。 ●在一个 deque 中,您可以添加和删除两端的项(无论是其前端还是后端)。 ○在本实验室,您将完成包括添加和删除在内的许多...
  • 数据结构的作业,只有尾指针的循环队列,可以入队出队打印等
  • 数据结构之循环队列C语言实现(详细)

    千次阅读 多人点赞 2020-05-25 23:59:25
    队列有两种,一种叫做循环队列(顺序队列),另一种叫做链式队列。 这一篇讲的是循环队列,链式队列在另外一篇文章中 循环数组 循环队列使用的是数组,但是这个数组比较特别,为循环数组。为什么要使用循环数组呢? ...
  • 循环队列实现杨辉三角的输出。通过该程序可以让你对循环队列有一定的理解。
  • 在哔哩哔哩看视频学的,赫斌老师数据结构入门的内容-b站搜索:av6159200(P47),通过学习循环队列,能独立把赫斌老师教的敲出来,并且自己摸索着实现链式队列. 第三部分最后面有我链式队列的ppt图解下载 二.什么是队列 ...
  • 该代码可在VC6.0平台直接编译运行,经...用数组实现了循环队列的操作,包括入队,出队,队列是否为空,队列是否为满,以及队列的遍历输出功能,各个子函数有详细的说明……希望对正在学习数据结构的同志有所帮组……
  • VC 运用循环队列链表技巧开发的贪吃蛇游戏,游戏的玩法和其它的贪食蛇游戏没什么区别,但是编程思路和运用的技巧却与其它的同类游戏大相径庭,本游戏运用了循环队列链表的技巧而编写,操作方法:按键盘上的W/A/S...
  • 链式存储结构中栈、队列循环链表,都是在上篇的单链表基础上进行实现的。话不多说先看链式存储的栈。 栈 先看一下的类图: 接下来是实现: public class LinkedStack<E> implements Stack<E>{ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 104,388
精华内容 41,755
关键字:

循环队列链表