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

    万次阅读 2017-03-07 14:05:38
    单向循环链表 和普通的链表结构不同,单向循环链表的最后一个节点的指针指向了头结点,也就是和Head指针有相同的引用 和普通链表相比,循环链表不需要头指针,能够从任意位置实现链表遍历 双向循环...

    单向循环链表

    和普通的链表结构不同,单向循环链表的最后一个节点的指针指向了头结点,也就是和Head指针有相同的引用



    和普通链表相比,循环链表不需要头指针,能够从任意位置实现链表遍历


    双向循环链表

    和单向链表相比,双向链表多了一个指向上一个节点的前向指针



    相比于单向链表,双向循环链表的遍历更加灵活,但缺点是,进行插入和删除操作需要修改更多的指针


    队列的“假溢出”


    如上图所示,front和rear分别是队列的头、尾指针,在出入队列的过程中会出现一种现象:尾指针指向了对垒的尾部,也就是达到了maxSize,但这是,头指针并没有指向对头,这样就造成的存储空间的浪费,也会导致队列无法继续实现入队、出队操作。因此,提出了循环队列。

    优先级队列

    和普通的队列相比,优先级队列在出栈是是按照优先级进行的,也就是每次选取优先级最高的元素出列,这在计算机的任务调度中有很大的用处

        private Object element;   //数据域
        private int priority;     //用整型数字表示对雷元素的优先级
    
        public Element(Object element, int priority) {
            this.element = element;
            this.priority = priority;
        }
    public Object delete() {
            if(isEmpty()){                //判断队列是否为空
                System.out.println("队列为空");
            }
    
                                         //找优先级最低的元素,默认为队头元素
            Element MIN = queue[0];
            int index = 0;
            for (int i = 0; i < count; i++) {
                if(queue[i].getPriority() < MIN.getPriority()){
                    MIN = queue[i];
                    index = i;
                }
            }
    
                                           //出队,后面的元素向前移
            for (int i = index + 1; i < count; i++) {
                queue[i -1] = queue[i];
                }
            rear--;
            count--;
            return MIN;
        }


    循环队列


    附上循环对垒的代码:

    public class ImplQueue implements CircularQueue{
    
        static final  int defauleSize = 10;
        int front,rear,count,maxSize;
        Object[] queue;
    
    
        public static void main(String[] args) {
            ImplQueue circleQueue = new ImplQueue();
            circleQueue.append(10);
            circleQueue.append("d");
            circleQueue.append("sss");
            circleQueue.append(1);
            System.out.println(circleQueue.isEmpty());
            System.out.println(circleQueue.getFront());
            while (!circleQueue.isEmpty()){
                System.out.println(circleQueue.delete());
            }
        }
    
        //默认队列长度
        public ImplQueue() {
            rear = 0;
            front = 0;
            count = 0;
            maxSize = defauleSize;
            queue = new Object[defauleSize];
        }
    
        //自定义队列那长度
        public ImplQueue(int maxSize) {
            this.maxSize = maxSize;
            rear = 0;
            front = 0;
            count = 0;
            queue = new Object[maxSize];
        }
    
        @Override
        public void append(Object obj) {
            //判断队列是否为满
            if(front == rear && count > 0) {
                System.out.println("队列已满,无法插入");
            }else {
                queue[rear] = obj;
                rear = (rear + 1) % maxSize;
                count++;
            }
        }
    
        @Override
        public Object delete() {
            Object obj = null;
            //判断队列是否为空
            if(isEmpty()){
                System.out.println("队列为空,无法删除");
            }else {
                obj = queue[front];
                front = (front +1) % maxSize;
                count--;
            }
            return obj;
        }
    
        @Override
        public Object getFront() {
            Object obj = null;
            if(isEmpty()){
                System.out.println("队列为空");
            }else {
                obj = queue[front];
            }
            return obj;
        }
    
        @Override
        public boolean isEmpty() {
            return count == 0;
        }
    }          
    展开全文
  • 链表循环队列程序

    2018-05-23 13:36:15
    链表循环队列简单的C语言程序供初学者参考,希望有用。
  • 循环链表实现队列操作 讲解详细 通过多次编译 可以运行的
  • 循环链表表示队列

    千次阅读 2021-10-24 11:52:41
    假设以带头结点的循环链表表示列队,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判队空、入队和出队等算法。 该算法使用循环链表表示列队。 在算法中只设一个指向队尾元素的指针...

    假设以带头结点的循环链表表示列队,并且只设一个指针指向队尾元素结点(注意不设头指针),试编写相应的置空队、判队空、入队和出队等算法。


    该算法使用循环链表表示列队。

    在算法中只设一个指向队尾元素的指针rear,在进行置空队,判队空等操作之前先将队列初始化;

    置空队则是将队尾指针指向头结点;

    入队则是在队尾插入元素,即在尾结点处插入元素,先申请一个新结点,再将新结点初始化并链入队列最后将尾指针移至新结点;

    出队是先判断队列是否为空,不为空则继续接下来的出队操作。


    该算法设计了个函数:

    函数initQueue()用来初始化列队;

    函数emptyQueue()用来将队置空;

    函数enqueue()用来将元素链入列队;

    函数delqueue()用来将元素出队;


    算法流程图

     

    源代码

    /*********
    date:2021-10-23
    author:sy
    version:1.0
    Description: 以带头结点的循环链表表示列队,只设一个指针指向队尾元素(不设头指针) 
    ***********/
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int elemType;
    /*定义结点类型*/ 
    typedef struct queuenode
    {
    	elemType data;
    	struct queuenode *next;
    }queuenode,*LinkQueue;
    
    typedef struct
    {
    	LinkQueue rear;  //只设一个指向队尾元素的指针 
    	int length;
    }sqqueue;
    
    /*初始化列队*/
    void initQueue(sqqueue &Q)
    {
    	Q.rear=(LinkQueue)malloc(sizeof(Q));
    	Q.rear->next=Q.rear;
    }
    /*置空队*/ 
    int emptyQueue(sqqueue &Q)
    {
    	if(Q.rear->next==Q.rear)  //将队尾指针指向头结点 
    		return 1;
    	else
    		return 0;
    }
    /*入队*/
    int enqueue(sqqueue &Q,elemType e)
    {   /*在尾结点处插入元素*/
    	LinkQueue p;
    	p=(LinkQueue)malloc(sizeof(Q));  //申请新结点 
    	if(!p)
    		return 0;
    	/*初始化新结点并链入*/ 
    	p->data=e;
    	p->next=Q.rear->next;
    	Q.rear->next=p;
    	Q.rear=p;  //将尾指针移至新结点 
    	return 1;
    }
    /*出队*/
    int delqueue(sqqueue &Q,elemType &e)
    {
    	LinkQueue p;
    	if(Q.rear->next==Q.rear)
    		return 0;  //若队列为空返回0
    	p=Q.rear->next->next;  //循环链表队列队尾指针下一结点(也即头结点)的下一结点(即队头指针)赋给p 
    	e=p->data;  // 保存结点中的数据 
    	Q.rear->next->next=p->next;  //摘下结点p 
    	free(p);   //释放被删结点 
    	return 1;
    }
    
    int main()
    {
    	sqqueue m;
    	elemType num;
    	initQueue(m);
    	if(emptyQueue(m))
    		printf("该队列目前为空!\n");
    	else
    		printf("该队列不为空!\n");
    	for(int i=1;i<=10;i++)
    		{
    			if(enqueue(m,i))
    			printf("元素%d成功入列!\n",i);
    		}
    	printf("\n\n");
    	for(int j=1;j<=10;j++)
    		{
    			if(delqueue(m,num))
    			printf("元素%d成功出列!\n",num);
    		}
    	if(emptyQueue(m))
    		printf("该队列目前为空!\n");
    	else
    		printf("该队列不为空!\n");
    	return 0;
    }
    

    函数delete()与函数free()函数 均可用来释放节点

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

    展开全文
  • 当我们使用数组的时候创建循环队列是为了节省存储空间,而来到链表中时,每一个节点都是动态申请和释放的,不会造成空间的浪费,所以不需要采用循环队列了。第二,大家在很多书上看到的是使用单链表实现队列,我这里...
  • 循环链表实现队列

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

    用循环链表实现队列

    实现方式:只是简单的链表插入与链表删除操作
    只是构造与析构时略有差别,注意循环结束时的判断,可以判断两个指针是否相遇,或者将链表改造成普通链表

    /*
     设以不带头结点的循环链表表示队列,
     并且只设一个指针指向队尾结点,
     但不设头指针。编写相应的入队和出队程序。
    */
    
    #include<iostream>
    using namespace std;
    struct Node {
    	int data;
    	Node* next;
    };
    
    class LinkQueue {
    private:
    	Node* rear;
    public:
    	LinkQueue() { rear = NULL; }
    	LinkQueue(int a[],int n);s 
    	int deQuee();
    	int enQuee(int n);
    	void printQueue();
    	~LinkQueue();
    };
    
    LinkQueue::LinkQueue(int a[], int n) {
    	Node* r=new Node, * s;  
    	r->data = a[1];
    	rear = r;
    	for (int i = 1; i < n; i++) {
    		s = new Node; 
    		s->data = a[i];        //s作为开拓数据空间的前驱指针
    		r->next = s; 
    		r = s;                          
    	}
    	r->next = rear;
    	rear = r;
    }
    
    //出队
    int LinkQueue::deQuee() {
    	if (rear == NULL) {
    		return 0;
    	}
    	Node* p = rear->next;
    	int temp =p ->data;
    	rear->next = p->next;
    	delete p;
    	return temp;
    }
    
    //入队
    int LinkQueue::enQuee(int n) {
    	Node* p = new Node;
    	p->data = n;
    	p->next = rear->next;
    	rear->next = p;
    	rear =p;
    	return 1;
    }
    
    void LinkQueue::printQueue() {
    	Node* p = rear->next;
    	while (p != rear) {
    		cout << p->data << "    ";
    		p = p->next;
    	}
    	cout << p->data << "    "<<endl;
    }
    
    LinkQueue::~LinkQueue() {
    	Node* p = rear->next,*q=rear;
    	while (rear->next != rear) {
    		p = rear->next;
    		rear->next = p->next;
    		delete p;
    	}
    }
    void main() {
    	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    	LinkQueue liq(a, 10);
    	liq.printQueue();
    	liq.enQuee(11);
    	liq.printQueue();
    	liq.deQuee();
    	liq.printQueue();
    
    }
    

    在这里插入图片描述

    展开全文
  • 数据结构篇:循环队列的C语言实现及其基本操作 #简述 循环队列在有些嵌入式软件开发中使用频繁,同时队列是非常重要的数据结构。 #include<stdio.h> #include<stdlib.h> #define Maxsize 20 //队列达到...
  • 假定一个单向循环链表来表示队列
  • 循环链表实现队列 队首位于单链表的头结点处,队尾位于单链表的尾结点处,尾结点的指针域指向头结点;维护尾指针和链表长度;当加入元素时,依据尾指针在尾结点后添加新元素,取出元素时候依据尾指针,取出尾结点...
  • 循环队列和顺序队列  队列的存储实现方式有哪些? 顺序存储(数组)和链式存储(链表),此博文描述的是数组的实现(后续更新链表实现)  代码实现 初始化队列:初始化一个size长度的队列,队列的值都为0 判断队列...
  • 1.单链表实现队列 # -*- coding:utf-8 -*- class LinkedQueue: class Node: def __init__(self,element,next): self.element = element self.next = next #创建一个空队列 def __init__(self): ...
  • 循环链表表示队列

    2013-07-19 16:43:13
    假设以带头结点的循环链表表示队列并且只设一个指针指向队尾元素结点 (注意不设头指针)试编写相应队列队列初始化,入队列和出队列的算法
  • 链式存储结构中栈、队列循环链表,都是在上篇的单链表基础上进行实现的。话不多说先看链式存储的栈。 栈 先看一下的类图: 接下来是实现: public class LinkedStack<E> implements Stack<E>{ ...
  • 若是不清楚链表的结构,该篇文章不适合观看,这里只做文字说明,没有链表结构的图示
  • 约瑟夫(Josephus)环问题: 设有n个人围成一圈,现从第s个人开始,拨顺时针方向从1开始报数,数到d的人退出圆圈,然后从退出圆圈的下一个人重新开始报数,数到d的人又退出...试将Josephus问题的求解过程用链表结构实现。
  • 数据结构:循环链表队列的入队、出队、置空

    千次阅读 多人点赞 2019-04-07 22:36:20
    假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素站点(注意不设头指针) ,试编写相应的置空队、判队空 、入队和出队算法。 链队结构: typedef struct queuenode{ Datatype data; struct queuenode...
  • 队列的特征就是“先入先出”,入队时在链表的尾部插入数据,出队时删除掉头节点后面的节点,需要一个尾指针,始终指向链表的尾部(新加进来的节点)。具体请看原理图: 代码实现 #include <stdio.h> #include...
  • 内容索引:VC/C++源码,游戏编程,贪吃蛇 又一个贪吃蛇i游戏的源码,虽然每一款贪吃蛇的玩法都相同,但是编程的算法却不同,本贪吃蛇有要是应用到VC++的循环队列和简单链表原理实现的,用键盘上的W/A/S/D键分别控制...
  • 循环链表实现循环队列

    千次阅读 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 "LLQueue.h"int main() { LLQueue lq; QueueInit(&lq); for (int i = 0; i ; i++) { QueueAppend(&lq, i + 1); printf("%d 入队列\n", i + 1);
  • 在哔哩哔哩看视频学的,赫斌老师数据结构入门的内容-b站搜索:av6159200(P47),通过学习循环队列,能独立把赫斌老师教的敲出来,并且自己摸索着实现链式队列. 第三部分最后面有我链式队列的ppt图解下载 二.什么是队列 ...
  • 本文代码均在turbo C 2.0 的环境下运行通过,并得到正确结果,本程序为用循环链表实现约瑟夫环,即有m个人站成一个圆环,从某人(队列第一个)开始报数,约定从某数开始的第n个人出列,他的下一个再从一开始报,然再...
  • 运用了类和对象的思想,在控制台上运行,按上下左右方向键控制方向。j
  • 队列 循环链表表示队列 假设以带头结点的循环链表表示队列,并且只设一个指针指向队尾元素结点(注意不设头指针),请完成下列任务: 1: 队列初始化,成功返回真,否则返回假: bool init_queue(LinkQueue *LQ); 2...
  • 假设以带头结点的循环链表表示一个队列,并且只设一个队尾指针指向尾元素结点(注意不设头指针),试写出相应的置空队、入队、出队的算法。(Java描述)
  • 基于循环链表队列的基本操作

    千次阅读 2018-04-06 21:22:43
    注意不设头指针,注意细节!!!#include&lt;bits/stdc++.h&gt; using namespace std; typedef struct node { int a; struct node *next; }node,*link; typedef struct { link rear;...Q,int ...
  • 双向链表的基本操作单链表基本一样,除了插入和删除的时候需要更改两个指针变量,需要注意的是修改的顺序很重要,插入如图3-14-5,删除如图3-14-6。 链表的delete操作需要首先找到要摘除的节点的前趋,而在...

空空如也

空空如也

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

循环链表与循环队列