循环队列算法

循环队列算法
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脚本语言环境中使用，该类未声明任何数据类型。 
    首先看一下该循环队列类的源代码： 
'* ************************************************************** *
'*    程序名称：Queue.cls
'*    程序功能：一个VB循环队列类
'*    作者：lyserver
'*    联系方式：http://blog.csdn.net/lyserver
'* ************************************************************** *
Option Explicit

'Class Queue '在ASP、WSH、HTML的VBScript脚本中使用时需加此句
    Dim m_Queue() '队列
    Dim m_RetQueue() '队列返回值
    Dim m_HeadOffset '列首偏移索引
    Dim m_WriteIndex '元素插入偏移索引
    Dim m_MaxLen '队列最大尺寸
      
    Private Sub Class_Initialize()
        m_HeadOffset = 0
        m_WriteIndex = 0
        m_MaxLen = 20 '队列默认大小为20
        ReDim m_Queue(m_MaxLen - 1)
    End Sub
      
    Private Sub Class_Terminate()
        Erase m_Queue
        Erase m_RetQueue
    End Sub
      
    '获得队列大小
    Public Property Get MaxLen()
        MaxLen = m_MaxLen
    End Property
      
    '设置队列大小
    Public Property Let MaxLen(ByVal NewValue)
        If NewValue > 0 Then
            m_MaxLen = NewValue
            ReDim m_Queue(m_MaxLen - 1)
        End If
    End Property
      
    '插入队列元素
    Public Sub Insert(ByVal v)
        m_Queue(m_WriteIndex Mod m_MaxLen) = v
        m_WriteIndex = m_WriteIndex + 1
        If m_WriteIndex > m_MaxLen Then m_HeadOffset = (m_HeadOffset + 1) Mod m_MaxLen
    End Sub
      
    '删除队列元素
    Public Sub Delete()
        Dim varEmpty
        m_Queue(m_HeadOffset) = varEmpty '将队列的列首元素置为未初始化
        m_HeadOffset = (m_HeadOffset + 1) Mod m_MaxLen
    End Sub
      
    '清空队列
    Public Sub Clear()
        ReDim m_Queue(m_MaxLen)
        m_WriteIndex = 0
        m_HeadOffset = 0
    End Sub
      
    '获得队列数组
    Public Property Get GetQueue()
        Dim i, n, trueLen
          
        n = 0
        ReDim m_RetQueue(m_MaxLen - 1)
        For i = m_HeadOffset To m_MaxLen - 1
            If IsEmpty(m_Queue(i)) Then Exit For
            m_RetQueue(n) = m_Queue(i)
            n = n + 1
        Next
        trueLen = i - m_HeadOffset
        For i = 0 To m_HeadOffset - 1
            If IsEmpty(m_Queue(i)) Then Exit For
            m_RetQueue(n) = m_Queue(i)
            n = n + 1
        Next
        If trueLen > 0 Then
            trueLen = trueLen + i
            ReDim Preserve m_RetQueue(trueLen - 1)
            GetQueue = m_RetQueue
        End If
    End Property
'End Class '在ASP、WSH、HTML的VBScript脚本中使用时需加此句

   
    然后，我们再来看一下在VB中如何使用此类： 
Sub main()
    Dim objQueue
    Dim i, nLen
    
    Set objQueue = New Queue
    '将队列长度置为5
    nLen = 5
    objQueue.MaxLen = nLen
    
    '向队列插入元素（不超过队列长度）
    For i = 1 To nLen
        objQueue.Insert i
    Next
    '显示结果
    DisplayQueue objQueue

    '清空队列后重新插入元素（超过队列长度）
    objQueue.Clear
    For i = 1 To nLen + 1
        objQueue.Insert i
    Next
    '显示结果
    DisplayQueue objQueue
    
    '删除队列元素
    objQueue.Delete
    '显示结果
    DisplayQueue objQueue
End Sub

Private Sub DisplayQueue(qu)
    Dim v(), i
    v = qu.GetQueue
    For i = 0 To qu.MaxLen - 1
        If IsEmpty(v(i)) Then Exit For
        Debug.Print "第" & i + 1 & "个元素的值：", v(i)
    Next
    Debug.Print "------显示完毕------"
End Sub
  
    看过了VB使用方法后，我们再来看一下在HTML的VBScript脚本中如何使用，需要注意的是，要想测试结果，必须将以下代码复制到记事本后另存为扩展名为html或htm的文件，然后使用IE打开，对于类代码，读者也可以单独取出来存为vbs文件，然后html里包含它就可以了。至于ASP，思路与此完全一样。 
<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>新建网页 1</title>
</head>

<body>
</body>
</html>
<mce:script language=vbscript><!--
Option Explicit
'* ************************************************************** *
'*    程序名称：Queue.cls
'*    程序功能：一个VB循环队列类
'*    作者：lyserver
'*    联系方式：http://blog.csdn.net/lyserver
'* ************************************************************** *
Class Queue
	Dim m_Queue() '队列
	Dim m_RetQueue() '队列返回值
	Dim m_ReadIndex '列首偏移索引
	Dim m_WriteIndex '元素插入偏移索引
	Dim m_MaxLen '队列最大尺寸
	
	Private Sub Class_Initialize()
	    m_ReadIndex = 0
	    m_WriteIndex = 0
	    m_MaxLen = 20 '队列默认大小为20
	    ReDim m_Queue(m_MaxLen - 1)
	End Sub
	
	Private Sub Class_Terminate()
	    Erase m_Queue
	    Erase m_RetQueue
	End Sub
	
	'获得队列大小
	Public Property Get MaxLen()
	    MaxLen = m_MaxLen
	End Property
	
	'设置队列大小
	Public Property Let MaxLen(ByVal NewValue)
	    If NewValue > 0 Then
	        m_MaxLen = NewValue
	        ReDim m_Queue(m_MaxLen)
	    End If
	End Property
	
	'插入队列元素
	Public Sub Insert(ByVal v)
	    If m_WriteIndex = m_MaxLen Then '队列已满，挤掉最先插入的元素
	        m_WriteIndex = 0
	        m_ReadIndex = (m_ReadIndex + 1) Mod m_MaxLen
	    End If
	    m_Queue(m_WriteIndex) = v
	    m_WriteIndex = m_WriteIndex + 1
	End Sub
	
	'删除队列元素（按队列原则，实际上是删除最先插入的元素）
	Public Sub Delete()
	    Dim vTemp
	    m_Queue(m_ReadIndex) = vTemp '将此变量置为未初始化
	    m_ReadIndex = (m_ReadIndex + 1) Mod m_MaxLen
	End Sub
	
	'清空队列
	Public Sub Clear()
	    ReDim m_Queue(m_MaxLen)
	    m_WriteIndex = 0
	    m_ReadIndex = 0
	End Sub
	
	'获得队列数组
	Public Property Get GetQueue()
	    Dim i, n
	    
	    n = 0
	    ReDim m_RetQueue(m_MaxLen)
	    For i = m_ReadIndex To m_MaxLen - 1
	        If IsEmpty(m_Queue(i)) Then Exit For
	        m_RetQueue(n) = m_Queue(i)
	        n = n + 1
	    Next
	    For i = 0 To m_ReadIndex - 1
	        If IsEmpty(m_Queue(i)) Then Exit For
	        m_RetQueue(n) = m_Queue(i)
	        n = n + 1
	    Next
	    GetQueue = m_RetQueue
	End Property

End Class

Sub window_onload
    Dim objQueue
    Dim i, nLen

    Set objQueue=New Queue

    '将队列长度置为5
    nLen = 5
    objQueue.MaxLen = nLen
    
    '向队列插入元素（不超过队列长度）
    For i = 1 To nLen
        objQueue.Insert i
    Next
    '显示结果
    DisplayQueue objQueue

    '清空队列后重新插入元素（超过队列长度）
    objQueue.Clear
    For i = 1 To nLen + 1
        objQueue.Insert i
    Next
    '显示结果
    DisplayQueue objQueue
    
    '删除队列元素
    objQueue.Delete
    '显示结果
    DisplayQueue objQueue
End Sub

Sub DisplayQueue(qu)
    Dim v,i
    v = qu.GetQueue
    For i = 0 To qu.MaxLen - 1
        If IsEmpty(v(i)) Then Exit For
        document.write "第" & i + 1 & "个元素的值：" & v(i) & "<br>"
    Next
    document.write "------显示完毕------<br>"
End Sub
// --></mce:script>  
    怎么样？如果读者觉得不满意，欢迎您留下宝贵的意见！

收起

展开全文

ASP

全部能够得到有效利用，试采用设置标志位tag的方法解决“假溢出”问题，实现顺序循环队列算法

千次阅读 2015-02-10 21:35:04

头文件：函数的声明 #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;
}

收起

展开全文

C语言

栈和队列算法四之循环队列

千次阅读 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函数就是模拟实现循环队列之后就能解决书上的问题了 

  

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

  
如果文章有什么错误或者有什么建议，欢迎提出，大家共同交流，一起进步 
 文章转载请注明出处，请尊重知识产权

收起

展开全文

c语言

顺序栈链栈顺序队列链式队列 循环队列的常用算法.zip
2019-08-16 09:37:08
主要包含顺序栈链栈顺序队列链式队列 循环队列的入队出队入栈出栈等常用算法操作
收起
C语言线性表之队列算法一：循环队列原码
2013-07-28 08:52:49
参见对此程序的解说：http://www.cnblogs.com/hymhblf/p/3220660.html
收起
c语言数据结构
C++循环队列实现模型
2020-09-04 00:13:41
主要介绍了C++循环队列实现模型,较为详细的分析了循环队列算法的原理与实现方法,具有一定的参考借鉴价值,需要的朋友可以参考下
收起
顺序存储结构的循环队列c算法的实现
2008-11-02 19:38:34
顺序存储结构的循环队列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;
}

收起

展开全文

C++

循环队列出队算法
千次阅读 2018-10-21 11:42:26
一棵具有n个结点的二叉树采用顺序存储结构，编写算法对该二叉树进行前序遍历顺序存储的前序遍历算法 Exchange template void PreOrder(T A[ ], int n) { top=-l; i= 1; cout<<A[]; S[++top]= i;j =2...
收起
数据结构-基本算法-循环队列
2017-05-21 19:02:30
数据结构-基本算法-循环队列(学生时代源码，调试可运行)
收起
【算法】循环队列
千次阅读 2016-01-31 17:33:11
C语言实现的循环队列。
收起
c语言
java数据结构与算法之双向循环队列的数组实现方法
2020-09-01 21:26:55
主要介绍了java数据结构与算法之双向循环队列的数组实现方法,结合实例形式分析了双向循环队列的原理与数组实现技巧,并附带说明了该算法的用途,需要的朋友可以参考下
收起
数据结构与算法——循环队列链式队列
千次阅读 2018-03-20 11:19:23
队列 1、也是一种操作受限的线性表，规定只能在一端插入，一端删除，有先进先出的特点。 ...1）为了区分队满和队空的条件，循环队列往往采用少用一个单元进行入队队满判定条件：（Q.rear+...
收起
链式队列
【郝斌数据结构自学笔记】35-46_队列的定义、分类_链式队列伪算法的讲解_循环队列伪算法的讲解
2015-11-22 23:02:57
35 _ 队列1 _ 什么是队列线性结构的两种常见应用之二队列定义：一种可以实现“先进先出”的存储结构 36 _ 队列2 _ ...链式队列伪算法的讲解 ...学习循环队列必须要弄清楚的7个问题概述静态队列
收起
数据结构 c语言队列
循环队列的基本算法
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
今天总结循环队列。什么是队列? 队列跟栈差不多，也是一种操作受限的线性表，只允许在线性表的一端进行插入操作，在另一端进行删除操作。插入的一端称为队尾，删除的一端称为队头，插入操作称为入队，而删除...
收起
数据结构数据结构队列队列实现
【数据结构与算法】循环队列和链队列的比较
千次阅读 2019-10-01 14:58:06
循环队列和链队列的比较
收起
数据结构 java
C#算法系列（10）——循环队列、链队列
千次阅读 2017-12-10 14:46:50
循环队列的提出主要是用于解决顺序队列的假溢出问题。解决假溢出的办法就是后面满了，再从头开始，头尾相接的循环。我们把队列的这种头尾相接的顺序存储结构称为循环队列。本文将从循环队列的顺序存储和链队列出发...
收起
链式队列 C#实现
循环队列
2020-03-13 22:56:22
文章目录循环队列（一）要求(二)循环队列结构一结构二（三） 循环队列的算法设计3.1 建立循环队列3.2 置空队列3.3 入队3.4 出队3.5 打印队3.6 完整代码 循环队列 （一）要求假设以数组sequ[m]存放循环队列的元素...
收起
数据结构
小白算法积累———队列1#循环队列+tag
2020-03-02 14:06:05
题目：若希望循环队列中的元素都能得到利用，则需设置一个标志域tag，并以tag的值为0或1来区分队头指针front和队尾指针rear相同时的队列状态是“空”还是“满”。试编写与此结构相应的入队和出队算法。关键字：...
收起
数据结构与算法系列-队列-循环队列
千次阅读 2013-11-10 22:14:43
定义： 循环队列: ...在循环队列中容量设为MANLEN，对首指针为front 队尾指针为rear 当rear=front时不能判定循环队列是满还是为空,对此做出规定 front = rear 是循环队列为空的标志.(rear+!)
收起
数据结构
算法-理论基础- 队列- 循环队列（包含源程序）.rar
2021-09-16 22:48:49
算法-理论基础- 队列- 循环队列（包含源程序）.rar
收起
Python实现数据结构与算法——设计循环队列
2020-02-27 00:43:33
设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用...
收起
数据结构 python
试给出此循环队列的队满条件，并写出相应的入队列和出队列的算法（在出队列的算法中要返回队头
千次阅读 2020-08-09 08:44:14
#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语言数据结构
循环队列的基本操作的c算法实现
2008-11-02 19:34:31
对循环队列的基本操作的c算法实现做了详细的编写，运行通过，里面还附有验证程序，保证算法的正确性。里面有的是动态申请空间的结构，克服了浪费空间的缺点。
收起
算法基础（四）：队列基础--循环队列
千次阅读 2014-03-01 14:06:35
算法基础--循环队列的实现。新手可以看看。欢迎交流！
收起
malloc 数据结构
数据结构：循环队列（一）设置一个标志域后的入队列和出队列的算法
万次阅读 多人点赞 2014-04-26 00:06:09
如果希望循环队列中的元素都能得到利用，则需设置一个标志域tag，并以tag的值为0或1来区分，尾指针和头指针值相同时的队列状态是"空"还是"满"。试编写与此结构相应的入队列和出队列的算法。本题的循环队列...
收起
c语言数据结构