精华内容
下载资源
问答
  • #include #include #include typedef struct Queue { int * pBase; int front; int rear; }QUEUE; void init(QUEUE *); bool en_queue(QUEUE *,int val); void traverse_queue(QUEUE *);...bool full_queue(QU
    #include<stdio.h> 
    #include<malloc.h>
    #include<stdlib.h>
    
    typedef struct Queue
    {
    	int * pBase;
    	int front;
    	int rear;	
    }QUEUE;
    
    void init(QUEUE *);
    bool en_queue(QUEUE *,int val);
    void traverse_queue(QUEUE *); 
    bool full_queue(QUEUE *);
    bool out_queue(QUEUE *, int *);
    bool emput_queue(QUEUE * );
    
    
    int main(void)
    {
    	Queue Q;
    	
    	init(&Q);
    	en_queue(&Q,1);
    	en_queue(&Q,2);
    	en_queue(&Q,3);
    	en_queue(&Q,4);
    	en_queue(&Q,5);
    	en_queue(&Q,6);
    	en_queue(&Q,7);
    	en_queue(&Q,8);
    	
    	traverse_queue(&Q);
    	
    	int val;
    	if(out_queue(&Q,&val))
    	{
    		printf("出队成功 元素是:%d\n",val);	
    	}
    	else
    	{
    		printf("出队失败\n");	
    	}
    	traverse_queue(&Q);
    	
    	system("pause");
    	return 0;	
    }
    
    void init(QUEUE *pQ)
    {
    	pQ->pBase = (int *)malloc(sizeof(int)*6);//指向一个数组 
    	pQ->front = 0;
    	pQ->rear = 0;	
    }
    
    bool full_queue(QUEUE * pQ)
    {
    	if((pQ->rear+1)%6 == pQ->front)
    		return true;
    	else
    		return false;	
    }
    
    bool en_queue(QUEUE * pQ,int val)//向里面放值 
    {
    	if(full_queue(pQ))
    	{
    		return false;
    			
    	}
    	else
    	{
    		pQ->pBase[pQ->rear] = val;
    		pQ->rear = (pQ->rear+1)%6;
    		 
    		return true;	
    	} 
    }
    void traverse_queue(QUEUE * pQ)
    {
    	int i = pQ->front;
    	
    	while(i != pQ->rear)
    	{
    		printf("%d ",pQ->pBase[i]);
    		i = (i+1)%6;	
    	}
    	printf("\n");
    	return;
    } 
    bool emput_queue(QUEUE * pQ)
    {
    	if(pQ->front == pQ->rear)
    		return true;
    	else
    		return false;
    		
    }
    bool out_queue(QUEUE * pQ, int *pVal)
    {
    	if(emput_queue(pQ))	
    	{
    		return false;	
    	}
    	else
    	{
    		*pVal = pQ->pBase[pQ->front];
    		pQ->front = (pQ->front+1)%6;
    		
    		return true;	
    	}
    }
    
    
    
    

     

    展开全文
  • 1.完整代码 #include<iostream> using namespace std; #define TRUE 1 ...#define MAXQSIZE 100 //最大队列长度 typedef int QElemType; typedef int Status; typedef struct{ QElemType *base;

    1.完整代码

    #include<iostream>
    using namespace std;
    
    #define TRUE    1
    #define FALSE   0
    #define OK      1
    #define ERROR   0
    #define OVERFLOW -2
    #define MAXQSIZE 100		//最大队列长度 
    typedef int QElemType;
    typedef int Status;
    
    typedef struct{
    	QElemType *base;
    	int front;				//头指针,若队列不空,指向队列头元素 
    	int rear;				//尾指针,若若队列不空,指向队列尾元素的下一个位置 
    }SqQueue;
    
    /********************基本功能函数**********************/ 
    //1.队列的初始化 
    Status InitQueue(SqQueue &Q)
    {
    	Q.base = new QElemType[MAXQSIZE];	//分配数组空间 
    	if ( !Q.base )						//存储分配失败 
    		exit(OVERFLOW);
    	Q.front = Q.rear = 0;				//头指针尾指针置零,队列为空 
    	return OK;
    }
    
    // 2.求队列的长度
    int QueueLength(SqQueue Q)
    {
    	return(Q.rear - Q.front + MAXQSIZE) / MAXQSIZE;
    } 
    
    //3.队列的入队
    Status EnQueue(SqQueue &Q, QElemType e)
    {
    	if ((Q.rear + 1) % MAXQSIZE == Q.front)		//队列内元素已满 
    		return ERROR;
    	Q.base[Q.rear] = e;
    	Q.rear = (Q.rear + 1) % MAXQSIZE;			//队尾指针+1 
    	return OK;
    } 
    
    //4.队列的出队
    Status DeQueue(SqQueue &Q, QElemType &e)
    {
    	if ( Q.front == Q.rear)						//队空 
    		return ERROR;
    	e = Q.base[Q.front];						//保存队头元素 
    	Q.front = (Q.front + 1) % MAXQSIZE;			//队头指针+1 
    } 
    
    //5.取队头元素 
    Status GetHead(SqQueue Q)
    {
    	if ( Q.front != Q.rear )					//队列不为空 
    		return Q.base[Q.front];					//返回队头指针元素的值,队头指针不变 
    } 
    
    /********************基本操作函数**********************/ 
    //入队功能函数 调用EnQueue函数
    void Enter_To_Queue(SqQueue &Q)
    {
    	int n;
    	QElemType e;
    	int flag;
    	printf("请输入入队元素个数(>=1): \n");
    	scanf("%d",&n);
    	for(int i=0; i<n; i++)
    	{
    	 	printf("请输入第%d个元素的值: ",i+1);
    	 	scanf("%d",&e);
    		flag=EnQueue(Q,e);
    	 	if(flag)
    			 printf("%d已入队\n",e);
    	 	else 
    		 {
    			 printf("队已满!!!\n");
    			 break;
    		 }
    	}
    }
    
    //出队函数 调用DeQueue函数
    void Delete_From_Queue(SqQueue &Q)
    {
    	int n;
    	QElemType e;
    	int flag;
    	printf("请输入出队元素个数(>=1): \n");
    	scanf("%d",&n);
    	for(int i=0;i<n;i++)
    	{
    		 flag=DeQueue(Q,e);
    		 if(flag)
    		 	 printf("%d已出队\n",e);
    		 else 
    		 {
    			 printf("队已空!!!\n");
    			 break;
    		 }
    	}
    }
    
    //获得队头元素 调用GetHead函数
    void Get_Head_Of_Queue(SqQueue Q)
    {
    	QElemType e;
    	bool flag; 
    	flag = GetHead(Q);
    	if(flag)
    		printf("队头元素为:%d\n",flag);
    	else 
    		printf("队已空!!!\n");
    }
    
    /*******************主函数*******************/ 
    int main()
    {
    	SqQueue Q;
    	InitQueue(Q);
    	Enter_To_Queue(Q);
    	printf("\n");
    	Get_Head_Of_Queue(Q);
    	printf("\n");
    	Delete_From_Queue(Q);
    	
    	return 0;
    } 
    
    

    2.测试结果

    在这里插入图片描述

    展开全文
  • #!/bin/bash read_index=-1 write_index=-1 n=3 readable=0 writeable=n read_one() {  echo "start to read...."  if [ $readable -le 0 ];then  echo "Cannot read anymore" ... 
    #!/bin/bash


    read_index=-1

    write_index=-1

    n=3

    readable=0
    writeable=n


    read_one()
    {
        echo "start to read...."
        if [ $readable -le 0 ];then
            echo "Cannot read anymore"
            return 1
        fi
      
        read_index=$(( (read_index+1) % n))
        readable=$((readable - 1))
        writeable=$((writeable + 1))
        echo "read from index : $read_index"

        echo "readable=$readable writeable=$writeable"
        return 0
    }


    write_one()
    {
        echo "start to write..."
        if [ $writeable -le 0 ];then
            echo "Cannot write anymore"
            return 1
        fi
       
        write_index=$(( (write_index+1) % n))
        readable=$((readable + 1))
        writeable=$((writeable - 1))
        echo "write from index : $write_index"
        
        echo "readable=$readable writeable=$writeable"
        return 0
    }


    # Start to unit test

    # r --- w changes to w --- r
    read_one
    read_one
    read_one
    read_one


    write_one
    write_one
    write_one
    write_one


    read_one
    read_one
    write_one


    echo '------------------------------'
    # w --- r  changes to r --- w
    read_one
    read_one


    write_one
    write_one
    write_one
    展开全文
  • 用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,思路与此完全一样。

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

     

     

    展开全文
  • 用VB实现循环队列算法收藏

    千次阅读 2009-07-06 14:29:00
    在日常代码编制时,许多人会忽略一些最基本的算法,导致代码冗余,思路不清楚。我曾经至少两次在CSDN里遇到这类问题:我想在页面的右边显示一个列表,列表长度为20,新加入一个用户后,显示在列表开头,再加入的用户...
  • 判断队列的长度的时候: return (q.rear-q.front+MAXQSIZE)%MAXQSIZE; //顺序实现队列 //若长度无法估计宜使用链队列 //用链表来实现 //使用方法二,当队头指针在队尾指针下一个位置时才判断队列为满 #...
  • 头文件:函数的声明 #include #include #define QUEUESIZE 100 typedef char ElemType; typedef struct ... ElemType queue[QUEUESIZE];...//标志位(入队列成功tag = 1,出队列成功tag = 0) }SCQueue; v
  • 队列算法:入队和出队 */ #include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef struct Queue { int * pBase; int front; int rear; }QUEUE; //函数声明参数一般不写 void init...
  • 请首先看上文:C语言线性表之队列算法一:链式队列 四、循环队列 1. 我们上文中提到的静态队列就是用循环队列实现的,那为什么静态队列必须要用循环队列来实现呢?比如说一个队列可以容纳5个元素,此时队列满的...
  • 栈和队列算法四之循环队列

    千次阅读 2014-05-05 09:09:04
    我们把队列的这种头尾相接的顺序存储结构称为循环队列。链式存储是不会出现这个问题的。   当队列为空时,此时front==rear,但是现在队列满的条件也是front==rear,怎么判断队列究竟是空还是满呢?  1.解决办法...
  • 主要包含顺序栈 链栈 顺序队列 链式队列 循环队列的入队出队 入栈出栈等常用算法操作
  • C++ 循环队列基本算法实现 #ifndef CircleQueue_h #define CircleQueue_h const int QueueSize = 1000; template <class T> class CircleQueue { public: CircleQueue(){front = rear = 0;} ...
  • 一个扩展队列的使用方法:循环队列; 两个企业级队列的应用:线性池中的任务队列 和 优先链式存储队列。 队列的原理 队列是一种受限的线性表,(Queue),它是一种运算受限的线性表,先进先出(FIFO F...
  • 循环队列我们再用队列得时候不知道发没发现这样一个问题.这是一个只有三个位置得队列,在进行三次加入(addqueue)操作和三次取出(get)操作之后再进行加入操作时候的样子.明显可以看到,队列已经无法使用了.队列是靠rear...
  • 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通...
  • C++循环队列实现模型

    2020-09-04 00:13:41
    主要介绍了C++循环队列实现模型,较为详细的分析了循环队列算法的原理与实现方法,具有一定的参考借鉴价值,需要的朋友可以参考下
  • 循环队列 #include <iostream> #include <stdlib.h> #include <algorithm> #include <vector> #include <iterator> using namespace std; //基于数组实现的循环队列 template<...
  • 先是循环队列,为什么不是顺序队列呢,顺序队列的有很多不足,每次我们做删除操作时,几乎所有元素都要移动,这显然大大提高复杂度,并不是我们想要的,但是循环队列就不一样了,插入删除不需要做大量元素的移动,只...
  • 循环队列的基本算法

    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);//入队的函数声明

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,630
精华内容 1,052
关键字:

循环队列算法