精华内容
下载资源
问答
  • 循环队列算法

    2016-03-11 21:23:40
    用c语言实现的循环队列代码
  • 用VB实现循环队列算法

    千次阅读 2009-05-04 00:15:00
    在日常代码编制时,许多人会忽略一些最基本的算法,导致代码冗余,思路不清楚。我曾经至少两次在CSDN里遇到这类问题:我想在页面的右边显示一个列表,列表长度为20,新加入一个用户后,显示在列表开头,再加入的用户...

        在日常代码编制时,许多人会忽略一些最基本的算法,导致代码冗余,思路不清楚。我曾经至少两次在CSDN里遇到这类问题:我想在页面的右边显示一个列表,列表长度为20,新加入一个用户后,显示在列表开头,再加入的用户,显示在这个用户的下边,当用户数量超过20后,挤掉最前面的那一位,第二位加入的用户成了第一位,依次循环,保证列表最多显示20位用户。当然,实际问题可能与此有些出入,比如Coder是想显示网友们最近选择的歌曲列表,但实际意思差不多。

        面对这个问题,大多数朋友会想到使用数据库。其实,这完全是一个队列,只不过,这个队列可以循环使用,在加入队列元素时,如果超过长度,会自动挤掉最先加入的。如果能够用代码直接实现,为什么要用数据库呢?考虑一下,为了提高网站性能,我们绞尽脑汁,却往往因为思路的偏差,导致性能降低。

        那么,在VB中如何实现可循环的队列呢?

        为此,我编写了一个循环队列类,以满足上述需要,同时为了方便在HTML、ASP、WSH的VBScript脚本语言环境中使用,该类未声明任何数据类型。

        首先看一下该循环队列类的源代码:

      

        然后,我们再来看一下在VB中如何使用此类:

        看过了VB使用方法后,我们再来看一下在HTML的VBScript脚本中如何使用,需要注意的是,要想测试结果,必须将以下代码复制到记事本后另存为扩展名为html或htm的文件,然后使用IE打开,对于类代码,读者也可以单独取出来存为vbs文件,然后html里包含它就可以了。至于ASP,思路与此完全一样。

        怎么样?如果读者觉得不满意,欢迎您留下宝贵的意见!

     

     

    展开全文
  • 头文件:函数的声明 #include #include #define QUEUESIZE 100 typedef char ElemType; typedef struct ... ElemType queue[QUEUESIZE];...//标志位(入队列成功tag = 1,出队列成功tag = 0) }SCQueue; v

    头文件:函数的声明

    #include <stdio.h>
    #include <stdlib.h>
    
    #define QUEUESIZE 100
    
    typedef char ElemType;
    typedef struct
    {
    	ElemType queue[QUEUESIZE];
    	int front;
    	int rear;
    	int tag;//标志位(入队列成功tag = 1,出队列成功tag = 0)
    }SCQueue;
    
    void InitQueue(SCQueue *SCQ);//将顺序队初始化
    int QueueEmpty(SCQueue SCQ);//判断顺序队是否为空
    int EnQueue(SCQueue *SCQ,ElemType e);//将元素e插入队列队尾
    int DeQueue(SCQueue *SCQ,ElemType *e);//删除对头元素
    void DisplayQueue(SCQueue SCQ);//输出队列
    int Gethead(SCQueue SCQ,ElemType *e);//获取队头元素
    void ClearQueue(SCQueue *SCQ);//清空队列




    函数的定义

    #include "循环队列.h"
    
    void InitQueue(SCQueue *SCQ)
    {
    	SCQ->front = SCQ->rear = 0;
    	SCQ->tag = 0;//标志位初始化
    }
    
    int QueueEmpty(SCQueue SCQ)
    {
    	if(SCQ.front == SCQ.rear && SCQ.tag == 0)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    }
    
    int EnQueue(SCQueue *SCQ,ElemType e)
    {
    	if(SCQ->front == SCQ->rear && SCQ->tag == 1)
    	{
    		return 0;
    	}
    	else
    	{
    		SCQ->queue[SCQ->rear] = e;
    		SCQ->rear = SCQ->rear + 1;
    		SCQ->tag = 1;
    		return 1;
    	}
    }
    
    int DeQueue(SCQueue *SCQ,ElemType *e)
    {
    	if(QueueEmpty(*SCQ)/*SCQ->front == SCQ->rear && SCQ->tag == 0*/)
    	{
    		return 0;
    	}
    	else
    	{
    		*e = SCQ->queue[SCQ->front];
    		SCQ->front = SCQ->front + 1;
    		SCQ->tag = 0;
    		return 1;
    	}
    }
    
    void DisplayQueue(SCQueue SCQ)
    {
    	int i;
    	if(QueueEmpty(SCQ))
    	{
    		return;
    	}
    	if(SCQ.front < SCQ.rear)
    	{
    		for(i = SCQ.front ;i < SCQ.rear ;i++)
    		{
    			printf("%c",SCQ.queue[i]);
    		}
    	}
    	else
    	{
    		for(i = SCQ.front ;i < SCQ.rear + QUEUESIZE;i++)
    		{
    			printf("%c",SCQ.queue[i%QUEUESIZE]);
    		}
    	}
    	printf("\n");
    }
    
    int Gethead(SCQueue SCQ,ElemType *e)
    {
    	if(SCQ.front == SCQ.rear && SCQ.tag == 0)
    	{
    		return 0;
    	}
    	else
    	{
    		*e = SCQ.queue[SCQ.front];
    		return 1;
    	}
    }
    
    void ClearQueue(SCQueue *SCQ)
    {
    	SCQ->front = SCQ->rear = 0;
    	SCQ->tag = 0;
    }


    函数的应用

    #include "循环队列.h"
    
    int main(void)
    {
    	SCQueue Q;
    	char e;
    	InitQueue(&Q);
    	printf("A入队\n");
    	EnQueue(&Q,'A');
    	printf("B入队\n");
    	EnQueue(&Q,'B');
    	printf("C入队\n");
    	EnQueue(&Q,'C');
    	printf("队列中的元素:");
    	DisplayQueue(Q);
    	printf("队头元素第一次出队\n");
    	DeQueue(&Q,&e);
    	printf("出队的元素:");
    	printf("%c\n",e);
    	printf("队头元素第二次出队\n");
    	DeQueue(&Q,&e);
    	printf("出队的元素:");
    	printf("%c\n",e);
    	printf("队列中的元素:");
    	DisplayQueue(Q);
    	printf("D入队\n");
    	EnQueue(&Q,'D');
    	printf("E入队\n");
    	EnQueue(&Q,'E');
    	printf("F入队\n");
    	EnQueue(&Q,'F');
    	printf("队列中的元素:");
    	DisplayQueue(Q);
    	return 0;
    }


    展开全文
  • 栈和队列算法四之循环队列

    千次阅读 2014-05-05 09:09:04
    我们把队列的这种头尾相接的顺序存储结构称为循环队列。链式存储是不会出现这个问题的。   当队列为空时,此时front==rear,但是现在队列满的条件也是front==rear,怎么判断队列究竟是空还是满呢?  1.解决办法...

       为了解决假溢出的办法就是当队尾"满"了,就再从头开始,也就是头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。链式存储是不会出现这个问题的。 

       当队列为空时,此时front==rear,但是现在队列满的条件也是front==rear,怎么判断队列究竟是空还是满呢?

       1.解决办法一是设置一个标志变量flag,当front==rear,且flag=0时为空队列,当front==rear,且flag=1时为队列满

       2.解决办法二是当队列为空时,条件还是front==rear,但是当队列满时,少用一个元素空间,约定为"队列头指针在队列尾指针的下一位置上"作为堆满条件,变成程序就是(rear+1)%MAXN==front

       基本上看的程序都是解决办法2,不知道为什么很少用解决办法一,解决办法一也不难,实现的代码还是照着书上的敲,感觉基本不需要修改,另外自己实现了getTop和getRear函数,分别是获取对头和队尾的元素,代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define MAXQSIZE 6
    
    struct SqQueue{
    	int *base;
    	int front;
    	int rear;
    };
    
    int InitQueue(SqQueue *queue){
    	queue->base=(int *)malloc(MAXQSIZE*sizeof(int));
    	if(!queue->base)  return 0;
    	queue->front=queue->rear=0;
    	return 1;
    }
    
    int QueueLength(SqQueue *queue){
    	return (queue->rear-queue->front+MAXQSIZE)%MAXQSIZE;
    }
    
    int EnQueue(SqQueue *queue,int e){
    	if((queue->rear+1)%MAXQSIZE==queue->front)  return 0;   //对满条件
    	queue->base[queue->rear]=e;
    	queue->rear=(queue->rear+1)%MAXQSIZE;
    	return 1;
    }
    
    int DeQueue(SqQueue *queue,int *e){
    	if(queue->rear==queue->front)  return 0;   //对空条件 
    	*e=queue->base[queue->front];
    	queue->front=(queue->front+1)%MAXQSIZE;
    	return 1;
    }
    
    int GetTop(SqQueue *queue){
    	if(queue->rear==queue->front)   return 0;
    	return queue->base[queue->front];
    }
    
    int GetRear(SqQueue *queue){
    	if(queue->rear==queue->front)  return 0;
    	return queue->base[queue->rear-1];
    }
    
    int main(){
    	SqQueue queue;
    	InitQueue(&queue);
    	int i;
    	for(i=0;i<3;i++) EnQueue(&queue,i+1);
    	printf("对长:%d\n",QueueLength(&queue));
    
    	int val=-1;
    	DeQueue(&queue,&val);
    	printf("出对元素:%d\n",val);
    	DeQueue(&queue,&val);
    	printf("出对元素:%d\n",val);
    	printf("对长:%d\n",QueueLength(&queue));
    
    	for(i=3;i<6;i++) EnQueue(&queue,i+1);
    	DeQueue(&queue,&val);
    	printf("出对元素:%d\n",val);
    	DeQueue(&queue,&val);
    	printf("出对元素:%d\n",val);
    	printf("对长:%d\n",QueueLength(&queue));
    
    	for(i=6;i<8;i++) EnQueue(&queue,i+1);
    	printf("对长:%d\n",QueueLength(&queue));
    	printf("对头元素:%d\n",GetTop(&queue));
    	printf("对尾元素:%d\n",GetRear(&queue));
    	return 1;
    }

        其中main函数就是模拟实现循环队列之后就能解决书上的问题了



    未完待续: 下一章 二叉树算法一之创建和遍历


    如果文章有什么错误或者有什么建议,欢迎提出,大家共同交流,一起进步

    文章转载请注明出处,请尊重知识产权

    展开全文
  • 主要包含顺序栈 链栈 顺序队列 链式队列 循环队列的入队出队 入栈出栈等常用算法操作
  • 参见对此程序的解说:http://www.cnblogs.com/hymhblf/p/3220660.html
  • C++循环队列实现模型

    2020-09-04 00:13:41
    主要介绍了C++循环队列实现模型,较为详细的分析了循环队列算法的原理与实现方法,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 顺序存储结构的循环队列c算法的实现,里面有调试程序,在vb中调试通过。
  • 数据结构与算法循环队列的操作

    千次阅读 2019-10-13 21:12:44
    数据结构与算法循环队列的操作 /* 循环队列的入队和出队算法设计 初始化循环队列 、打印队列、插入元素到循环队列、获取循环队列的首元素,元素不出队、出队、获取循环队列元素个数、判断循环队列的空和满。 核心:...

    数据结构与算法之循环队列的操作

    /*
    循环队列的入队和出队算法设计
    初始化循环队列 、打印队列、插入元素到循环队列、获取循环队列的首元素,元素不出队、出队、获取循环队列元素个数、判断循环队列的空和满。

    核心:
    循环队列入队, 队尾循环后移: SQ->rear =(SQ->rear+1)%Maxsize;
    循环队列出队, 队首循环后移: SQ->front =(SQ->front+1)%Maxsize;
    队空:SQ.front=SQ.rear; // SQ.rear 和 SQ.front 指向同一个位置
    队满: (SQ.rear+1) %Maxsize=SQ.front; // SQ.rear 向后移一位正好是 SQ.front
    计算元素的个数: (SQ.rear-SQ.front+Maxsize)% Maxsize;

    */

    //循环队列的入队和出队算法设计
    #include<iostream>
    #include<Windows.h>
    
    #define MaxSize 6	//定义本循环队列的最大容量
    
    using namespace std;
    
    typedef struct _LQueue {		//循环队列
    	int sq[MaxSize];
    	int front;	//循环队列的前指针
    	int rear;	//循环队列的尾指针
    }LqList;
    
    //初始化循环队列
    bool InitLqList(LqList *duilie) {
    	if (!duilie) return false;
    	duilie->front = duilie->rear = 0;
    	return true;
    }
    //插入元素到循环队列
    bool InserLq(LqList* duilie, int &Element) {
    	if (!duilie) return false;
    	if ((duilie->rear + 1) % MaxSize == duilie->front) {
    		cout << "该队列元素已满! ";
    	} else {
    		duilie->sq[duilie->rear] = Element;
    		duilie->rear =( duilie->rear + 1)%MaxSize;
    	}
    	return true;
    }
    //打印队列
    void PrintLq(LqList *duilie) {
    	if (!duilie) return;
    	cout << "本循环队列的元素依次是:  ";
    	int i = duilie->front;
    	while (i != duilie->rear) {
    		cout <<" "<< duilie->sq[i]; 
    		i = (i + 1) % MaxSize;
    	}
    	return;
    }
    //获取循环队列的首元素,元素不出队
    bool GetLqFirst(LqList *duilie, int &Element) {
    	if (!duilie) return false;
    	Element = duilie->sq[duilie->front];
    	return true;
    }
    //出队
    bool outLq(LqList *duilie,int &Element){
    	if (!duilie) return false;
    	if (duilie->front == duilie->rear) {
    		cout << "该队列是空队列! "; 
    		return false;
    	} else {
    		Element = duilie->sq[duilie->front];
    		duilie->front = (duilie->front + 1) % MaxSize;
    	}
    	return true;
    }
    //获取循环队列元素个数
    void Getlen(LqList *duilie) {
    	cout << "循环队列的元素个数是:  " << (duilie->rear - duilie->front + MaxSize) % MaxSize;
    	return;
    }
    
    
    int main(void) {
    	LqList *duilie =new LqList;
    	if (InitLqList(duilie)) {
    		cout << "初始化循环队列成功! " << endl;
    	} else {
    		cout << "初始化循环队列失败! " << endl;
    	}
    
    	//循环队列入队
    	int num;	//用户想要入队或者出队的个数
    	cout << "请输入你想要入队的个数(本程序设置的循环队列最大容量为5): ";
    	cin >> num;
    	//直到用户输入正确的入队个数为止
    	while (1) {	
    		if (num > MaxSize) {
    			cout << "输入的数量超过了本队列的最大容量,请重新输入入队的个数:  " << endl;
    			cout << "请输入你想要入队的个数: ";
    			cin >> num;
    		} else {
    			break;
    		}
    	}
    	int Element = 0;
    	for (int i = 0; i < num; i++) {
    		cout << "请输入你想要插入的元素: ";
    		cin >> Element;
    		if (InserLq(duilie,Element)) {
    			cout << "插入元素 " << Element << " 成功! " << endl;
    		} else {
    			cout << "插入元素失败! " << endl;
    		}
    	}
    	//打印循环队列里的元素
    	PrintLq(duilie);
    	//获取循环队列的首元素,元素不出列
    	if (GetLqFirst(duilie,Element)) {
    		cout << "循环队列的首元素是: " << Element << endl;
    	} else {
    		cout << "获取循环队列首元素失败! " << endl;
    	}
    	//循环队列出队
    	cout << "请输入你想要出队的个数: ";
    	cin >> num;
    	cout << endl;
    	//直到用户输入正确的出队个数为止
    	while (1) {
    		if (num > (duilie->rear - duilie->front + MaxSize) % MaxSize) {
    			cout << "输入的数量超过了本队列的最大容量,请重新输入出队的个数:  " << endl;
    			cout << "请输入你想要出队的个数: ";
    			cin >> num;
    		} else {
    			break;
    		}
    	}
    	for (int i = 0; i < num; i++) {
    		if (outLq(duilie, Element)) {
    			cout << "循环队列元素出队成功! 出队元素是:   " << Element << endl;
    		} else {
    			cout << "循环队列元素出队失败! " << endl;
    		}
    	}
    	PrintLq(duilie);
    	Getlen(duilie);
    
    	cout << "在入队一个元素吧,这可是循环队列哟!" << endl;
    	cout << "请输入你想要插入的元素: ";
    	cin >> Element;
    	if (InserLq(duilie, Element)) {
    		cout << "插入元素 " << Element << " 成功! " << endl;
    	} else {
    		cout << "插入元素失败! " << endl;
    	}
    	
    	PrintLq(duilie);
    
    	
    	system("pause");
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 循环队列出队算法

    千次阅读 2018-10-21 11:42:26
    一棵具有n个结点的二叉树采用顺序存储结构,编写算法对该二叉树进行前序遍历 顺序存储的前序遍历算法 Exchange template void PreOrder(T A[ ], int n) { top=-l; i= 1; cout&lt;&lt;A[]; S[++top]= i;j =2...
  • 数据结构-基本算法-循环队列(学生时代源码,调试可运行)
  • 算法循环队列

    千次阅读 2016-01-31 17:33:11
    C语言实现的循环队列
  • 主要介绍了java数据结构与算法之双向循环队列的数组实现方法,结合实例形式分析了双向循环队列的原理与数组实现技巧,并附带说明了该算法的用途,需要的朋友可以参考下
  • 队列 1、也是一种操作受限的线性表,规定只能在一端插入,一端删除,有先进先出的特点。 ...1)为了区分队满和队空的条件,循环队列往往采用少用一个单元进行入队 队满判定条件:(Q.rear+...
  • 35 _ 队列1 _ 什么是队列 线性结构的两种常见应用之二 队列 定义:  一种可以实现“先进先出”的存储结构 36 _ 队列2 _ ...链式队列伪算法的讲解 ...学习循环队列必须要弄清楚的7个问题概述 静态队列  
  • 循环队列的基本算法

    2020-10-15 16:40:55
    //队列最大容量 int f;//队头指针 int r;//队尾指针 }SqQueue; void main() { void init(SqQueue &q,int n);//初始化队列的函数声明 void enQueue(SqQueue &q,char e);//入队的函数声明
  • 数据结构与算法——循环队列

    千次阅读 2015-05-14 21:43:49
    今天总结循环队列。 什么是队列?  队列跟栈差不多,也是一种操作受限的线性表,只允许在线性表的一端进行插入操作,在另一端进行删除操作。插入的一端称为队尾,删除的一端称为队头,插入操作称为入队,而删除...
  • 循环队列和链队列的比较
  •  循环队列的提出主要是用于解决顺序队列的假溢出问题。解决假溢出的办法就是后面满了,再从头开始,头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。本文将从循环队列的顺序存储和链队列出发...
  • 循环队列

    2020-03-13 22:56:22
    文章目录循环队列(一) 要求(二)循环队列结构一结构二(三) 循环队列算法设计3.1 建立循环队列3.2 置空队列3.3 入队3.4 出队3.5 打印队3.6 完整代码 循环队列 (一) 要求 假设以数组sequ[m]存放循环队列的元素...
  • 题目:若希望循环队列中的元素都能得到利用,则需设置一个标志域tag,并以tag的值为0或1来区分队头指针front和队尾指针rear相同时的队列状态是“空”还是“满”。 试编写与此结构相应的入队和出队算法。 关键字:...
  • 数据结构与算法系列-队列-循环队列

    千次阅读 2013-11-10 22:14:43
    定义: 循环队列: ...在循环队列中 容量设为MANLEN,对首指针为front 队尾指针为rear 当rear=front时 不能判定循环队列是满还是为空,对此做出规定 front = rear 是循环队列为空的标志.(rear+!)
  • 算法-理论基础- 队列- 循环队列(包含源程序).rar
  • 设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用...
  • #include<stdio.h> #include <stdlib.h> #define MaxQSize 7 typedef int ElemType; typedef struct{ ElemType *base; int rear; int length; }Queue; Queue InitQueue(){ ... Q.l
  • 顺序队列的基本算法循环队列

    千次阅读 2011-12-26 01:02:01
    队列的顺序存储结构类型描述如下: #define M 1000 QElemType queue[ M ]; int front, rear; 队头指针front指出实际队头元素所在位置的前一个位置,而队尾指针rear指出实际队尾...顺序队列的基本算法如下: /* 顺
  • 循环队列–C语言实现–数据结构

    万次阅读 多人点赞 2017-06-22 16:36:45
    循环队列算法设计 1 建立循环队列 2 置空队列 3 入队 4 出队 5 打印队 四 程序 1 程序的结构 2 程序源码 五 程序测试 1 入队列 2 出队列 3 打印队列 六 源程序及封装软件下载 下载地址 格格是一枚智能专业的...
  • 循环队列的基本操作的c算法实现做了详细的编写,运行通过,里面还附有验证程序,保证算法的正确性。里面有的是动态申请空间的结构,克服了浪费空间的缺点。
  • 算法基础--循环队列的实现。新手可以看看。欢迎交流!
  • 如果希望循环队列中的元素都能得到利用,则需设置一个标志域tag,并以tag的值为0或1来区分,尾指针和头指针值相同时的队列状态是"空"还是"满"。试编写与此结构相应的入队列和出队列的算法。 本题的循环队列...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,588
精华内容 62,235
关键字:

循环队列算法