精华内容
下载资源
问答
  • 循环队列 输出杨辉三角

    千次阅读 2016-04-01 23:53:17
    //添加队列元素 { if ((H.rear+ 1 )%MAXQSIZE==H.front) { printf ( "队列已满\n" ); return 0 ; } H.data[H.rear]=e; H.rear=(H.rear+ 1 )%MAXQSIZE; return 1 ; } int QueueLength(SqQueue &H)...

    主要在于travelQueue函数的编写,一看应该就会明白

    #include <iostream>
    #include <cstring>
    #include <cstdio>
    #include <cstdlib>
    #define MAXQSIZE 100
    using namespace std;
    
    typedef struct node
    {
        int data[MAXQSIZE];
        int front,rear;
    } SqQueue;
    bool InitQueue(SqQueue &H)//创建队列
    {
        H.front=0;
        H.rear=0;
        return 1;
    }
    bool EnQueue(SqQueue &H,int e)//添加队列元素
    {
        if((H.rear+1)%MAXQSIZE==H.front)
        {
            printf("队列已满\n");
            return 0;
        }
        H.data[H.rear]=e;
        H.rear=(H.rear+1)%MAXQSIZE;
        return 1;
    }
    int QueueLength(SqQueue &H)//返回队列长度
    {
        return (H.rear-H.front+MAXQSIZE)%MAXQSIZE;
    }
    bool deleteEle(SqQueue &H,int &e)//删除队列元素
    {
        if(H.front==H.rear)
        {
            cout<<"队列为空!"<<endl;
            return 0;
        }
        e=H.data[H.front];
        H.front=(H.front+1)%MAXQSIZE;
        return 1;
    }
    int getHead(SqQueue H)//得到队列头元素
    {
        return H.data[H.front];
    }
    int QueueEmpty(SqQueue H)//判断队列是否为空
    {
        if (H.front==H.rear)
            return 1;
        else
            return 0;
    }
    void travelQueue(SqQueue &H,int k)//遍历输出
    {
        int a=0;
        int p=0;
        for(int i=1; i<=k; i++)
        {
            p=a;
            deleteEle(H,a);
            printf("%5d ",a);
            EnQueue(H,a+p);
        }
        EnQueue(H,a);
        cout<<endl;
    }
    int main()
    {
        int n;
        while(1)
        {
            printf("输入要输出的杨辉三角行数:\n");//n不要太大了
            cin>>n;
            SqQueue S;
            InitQueue(S);
            EnQueue(S,1);
            for(int i=1; i<=n; i++)
            {
                travelQueue(S,i);
            }
        }
        return 0;
    }
    
    
    展开全文
  • 循环队列输出直角杨辉三角

    千次阅读 2015-01-28 11:04:09
    思想:杨辉三角的第n行的第i个数字.../*用循环队列解决输出杨辉三角的问题*/ #include #include #define MAXSIZE 50 typedef int ElementType; struct Queue//声明结构体 { ElementType data[MAXSIZE]; int fr

    思想:杨辉三角的第n行的第i个数字等于第n-1行的第i-1个数字和第i个数字的和(其中i不等于1,不等于n)

    /*用循环队列解决输出杨辉三角的问题*/
    #include <stdio.h>
    #include <malloc.h>
    #define MAXSIZE 50
    
    typedef int ElementType;
    struct Queue//声明结构体 
    {
    	ElementType data[MAXSIZE];
    	int front;//循环队列和顺序栈中使用整型值来表示首尾 
    	int rear;//队尾指针指向队尾元素的下一单元 
    };
    int InitQueue(Queue *Q)//对队列进行初始化
    {
    		Q->rear=Q->front=0;
    } 
    int IsEmpty(Queue* Q)
    {
    	if(Q->front==Q->rear) return true;
    	else return false;
    }
    int IsFull(Queue* Q)
    {
    	if(Q->front==(Q->rear+1)%MAXSIZE) return true;
    	else return false; 
    }
    int EnterQueue(Queue* Q,ElementType x)
    {
    	if(IsFull(Q)==false)
    	{
    	    Q->data[Q->rear]=x;
         	Q->rear=(Q->rear+1)%MAXSIZE;
         	return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    int DeleteQueue(Queue *Q,ElementType *x)
    {
    	if(IsEmpty(Q)==false)
    	{
    		*x=Q->data[Q->front];
    		Q->front=(Q->front+1)%MAXSIZE;
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    int GetHead(Queue *Q,ElementType *x)
    {
    	if(IsEmpty(Q)==true) return false;
    	else 
    	{
    		*x=Q->data[Q->front];
    		return true;
    	}
    }
    void ClearQueue(Queue *Q)
    {
    	Q->rear=Q->front=0;
    	
    }
    void DestroyQueue(Queue *Q)
    {
    	free(Q->data);//销毁队列,将结构体的数组销毁,数组名即是地址 
    }
    int main()
    {
    	void YangHuiTriangle(int n);
    	int N=20;
    	YangHuiTriangle(N);
    	return 0;
    }
    void YangHuiTriangle(int N)
    {
    	ElementType *x=(ElementType *)malloc(sizeof(ElementType)); 
    	ElementType *temp=(ElementType *)malloc(sizeof(ElementType)); 
    	Queue *Q=(Queue *)malloc(sizeof(Queue));
    	InitQueue(Q);
    	EnterQueue(Q,1);
    	for(int n=2;n<=N;n++)
    	{
    		EnterQueue(Q,1);
    		for(int i=1;i<=n-2;i++)
    		{
    			DeleteQueue(Q,temp);
    			printf("%d ",*temp);
    			GetHead(Q,x);
    			*temp=*temp+*x;
    			EnterQueue(Q,*temp);
    		}
    		DeleteQueue(Q,x);
    		printf("%d \n",*x);
    		EnterQueue(Q,1);
    	}
        
    } 


    展开全文
  • *进入第二个循环将第i行的第一个元素出队 并得到第二个元素的值 *然后将出队的值进行输出 *将a1和a2的值进行计算 然后入队 *第二层循环结束 进入第一层的后期循环 *将i行的最后一个元素进行出队并输出 *最后将i+1行...

    /*利用循环链表打印杨辉三角算法逻辑
    *第一步先将第一行的1输出
    *将第二行 的两个1进行入队操作
    *从第二行开始 先将下一行的第一个元素1入队
    *进入第二个循环将第i行的第一个元素出队 并得到第二个元素的值
    *然后将出队的值进行输出
    *将a1和a2的值进行计算 然后入队
    *第二层循环结束 进入第一层的后期循环
    *将i行的最后一个元素进行出队并输出
    *最后将i+1行的最后一个元素1入队
    *主要利用循环队列的先进先出的规则
    */

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 1024
    typedef  int element;
    typedef struct seqqueue
    {
        element data[MAXSIZE];
          int front;
          int rear;
    }Seq_Queue;
    Seq_Queue*init_seqqueue();//循环队列的初始化
    void fun(int n);//函数实现
    void enter_seqqueue(Seq_Queue*Q,element x);//循环队列元素入队
    void delet_seqqueue(Seq_Queue*Q,int *x);//循环队列的出队
    void getdata_seqqueue(Seq_Queue*Q,int *x);//取对头元素
    void main()
    {
        int n;
        printf("请输入杨辉三角的行数:\n");
         scanf("%d",&n);
         printf("打印的杨辉三角为:\n");
            fun(n);
    }
    Seq_Queue*init_seqqueue()//循环队列的初始化
    {
        Seq_Queue*q;
        q=(Seq_Queue*)malloc(sizeof(Seq_Queue));
          if(q==NULL)
             return NULL;
            else
               {
                   q->front=0;
                   q->rear=0;
               }
               return q;
    }
    void   enter_seqqueue(Seq_Queue*Q,element x)//循环队列元素入队
    {
                Q->data[Q->rear]=x;
              Q->rear=(Q->rear+1)%MAXSIZE;
    }
    void  delet_seqqueue(Seq_Queue*Q,int *x)//循环队列的出队
    {
         *x=Q->data[Q->front];
         Q->front=(Q->front+1)%MAXSIZE;
    }
    void getdata_seqqueue(Seq_Queue*Q,int *x)//取对头元素
    {
        *x=Q->data[Q->front];
    
    }
    void fun(int n)//函数实现
    {
        int i,k;
        Seq_Queue*q;
        q=init_seqqueue();
        int a1,a2;
        printf("%d\n",1);
         enter_seqqueue(q,1);
          enter_seqqueue(q,1);
          for(i=2;i<=n;i++)
          {
              enter_seqqueue(q,1);//将i+1个元素入队
              for(k=0;k<=i-2;k++)
                {
                    delet_seqqueue(q,&a1);//将队列第一个元素出队
                    getdata_seqqueue(q,&a2);//得到队列的第二个元素的值
                     printf("%d ",a1);
                       enter_seqqueue(q,a1+a2);
                       //将i+1行的计算后的结果入队
                }
                  delet_seqqueue(q,&a2);//使第i行的最后一个元素出队
                  printf("%d\n",a2);//打印第i行最后一个元素
                 enter_seqqueue(q,1);//将i+1的最后一个元素入队
        }
    }
    
    
    
    展开全文
  • 利用循环队列打印输出杨辉三角

    千次阅读 2016-04-04 10:32:50
    对于计算机专业的童鞋来说,学习每一门专业课,打印杨辉三角总是一个亘古不变的话题,这不,连《数据结构》这么高大上的科目,也通过循环队列的实现来找上了我们。 首先,先来大致解释一下什么是循环队列。回忆起...

    对于计算机专业的童鞋来说,学习每一门专业课,打印杨辉三角总是一个亘古不变的话题,这不,连《数据结构》这么高大上的科目,也通过循环队列的实现来找上了我们。

    首先,先来大致解释一下什么是循环队列。回忆起学习一般的线性表和特殊的线性表—栈时,我们都是先去学习其顺序结构,因为顺序结构由于是物理结构和逻辑一致,好理解也好实现,掌握好顺序结构之后又去学习其链式结构。而学习队列时却恰恰相反,我们却先学习了链队列,后又学习顺序队列,就是因为正常来使用顺序队列会产生假溢出的情况,所以我们不得不通过一种对Maxsize求余的算法,引入循环队列,这样即可以解决假溢出的问题,又可以充分利用空间,何乐而不为呢!

    循环队列实现方法:

    约定:

    1. 队首指针指向队首元素的前一个,且队首指针处于没有元素的位置;

    2. 队尾指针指向队尾元素

    初始化:  Q.rear=Q.front=0;

    入队操作:  Q.rear=(Q.rear+1)%Maxsize;

    出队操作:  Q.front=(Q.front+1)%Maxsize;

    判断队满:  (Q.rear+1)%Maxsize==Q.front;

    判断队空:  Q.rear==Q.front;

    队列中元素的个数: (Q.rear-Q.front+Maxsize)%Maxsize;


    代码实现:(循环队列基本实现+打印前n行杨辉三角)

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    
    #define Maxsize 1000000
    #define OK 1
    #define OVERFLOW -2
    
    using namespace std;
    
    typedef long long ElemType;
    
    typedef struct
    {
        ElemType *base;
        int front;
        int rear;
    } SeqQueue;
    
    int InitQueue(SeqQueue &Q)
    {
        Q.base=(ElemType *)malloc(Maxsize*sizeof(ElemType));
        if(!Q.base)
            exit(OVERFLOW);
        Q.front = Q.rear =0;
        return OK;
    }
    
    int GetSum(SeqQueue&Q)
    {
        int sum=Q.base[Q.front+1]+Q.base[Q.front+2];
        return sum;
    }
    
    int EnQueue(SeqQueue &Q,ElemType e)
    {
        if((Q.rear+1)%Maxsize==Q.front)
        {
            cout<<"Queue Full"<<endl;
            return 0;
        }
        Q.rear = (Q.rear+1)%Maxsize;
        Q.base[Q.rear]=e;
        return 1;
    }
    
    int DeleQueue(SeqQueue &Q,ElemType &e)
    {
        if(Q.front==Q.rear)
        {
            cout<<"Queue Empty"<<endl;
            return 0;
        }
        Q.front=(Q.front+1)%Maxsize;
        e=Q.base[Q.front];
        return 1;
    }
    
    int QueueLength(SeqQueue Q)
    {
        return (Q.rear-Q.front+Maxsize)%Maxsize;
    }
    
    int main()
    {
        SeqQueue QQ;
        int flag;
        int n;
        while(scanf("%d",&n)!=EOF)
        {
            flag=InitQueue(QQ);
            int k;
            if(flag==1)
            {
                for(k=1; k<=n; k++)
                {
                    for(int i=1; i<=k-2; i++)
                    {
                        int sum=GetSum(QQ);
                        flag=EnQueue(QQ,sum);
                        if(flag==0) break;
                        ElemType e;
                        flag=DeleQueue(QQ,e);
                        if(flag==0) break;
                    }
                    // if(flag==0) break;
                    flag=EnQueue(QQ,1);
                    if(flag==1)
                    {
                        for(int i=1; i<=k; i++)
                        {
                            cout<<QQ.base[QQ.front+i]<<" ";
                        }
                        cout<<endl;
                    }
                }
            }
            if(flag==0)
            {
                cout<<"Can not do it"<<endl;
            }
        }
        return 0;
    }
    

    最多打印30行左右


    展开全文
  • 循环队列的操作(循环队列

    千次阅读 2013-10-17 18:58:46
    循环队列满时,将循环队列中的所有元素全部出队,并按存入的先后顺序在同一行内依次输出,即每行输出m个元素,每个元素输出一个空格。   Input 有多组数据,每组第一行为整数序列的个数n和循环队列的最大容
  • 循环队列

    2018-05-03 22:43:10
    假设将循环队列定义为:以域变量rear和length分别指示循环队列中队尾元素的位置和内含元素的个数。编写相应的入队列和出队列的程序,并判断...输出入队出队操作后的循环队列,并返回出队元素的队头元素。53 4 6 2 7...
  • 实现循环队列初始化、进队出队、打印输出所有队列元素、获取队头元素,dos窗口输出。一般队列可在此基础上修改即可!
  • 循环队列应用

    2018-11-06 23:10:50
    郭艳数据结构作业之循环队列的应用与斐波拉契。题目如下: 在K_Fib.h文件中K_Fib()函数实现计算并输出K阶斐波那契序列...在算法执行结束时,留在循环队列中的元素应是所求K阶斐波那契序列中的最后K项f(n-k+1),…,fn。
  • 队列,循环队列为什么用空一个元素的位置 队列介绍 1)队列是一个有序列表,可以用数组或是链表表示。 2)遵循先入先出的原则。即:先存入队列的数据,要先取出。后存入的要后取出。 front及rear分别记录队列前后端...
  • 循环队列和队列

    2013-08-09 08:51:36
    例如,给定5个元素空间构造循环队列,则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即完成给定入队及出列操作后一次性全部出队的元素值。要求采用顺序队列完成。...
  • 队列实现循环队列

    千次阅读 2018-04-20 21:53:40
    二、实验内容仿照资料中顺序循环队列的例子,设计一个只使用队头指针和计数器的顺序循环队列抽象数据类型。其中操作包括:初始化、入队列、出队列、判断队列是否非空。编写主函数,验证所设计的顺序循环队列的正确性...
  • 循环队列里添加删除元素

    千次阅读 2017-11-14 10:51:11
    //如果尾指针小于头指针,线输出到Maxsize,再从头输出 { for (int j = k->front; j <= k->Maxsize; j++) cout << Q->Data[j] ; for (int j = 0; j <= k->rear; j++) cout << Q->Data[j] ...
  • C语言——循环队列

    千次阅读 2018-12-26 20:20:46
    循环队列 遵循先进先出(FIFO) 浪费一个空间,让循环队列更好的判断满/空,更好运用循环队列 黑色代表空时状态,红色代表满时状态 下面代码: #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; ...
  • 由用户输入n个10以内的数,每输入i(0=),就把它插入到第i号队列中。最后把10个队列中非空队列,按队列号从小到大的顺序串成一个链,并输出该链的所有元素。 数据结构上机作业 第二章14 张宪超
  • 队列只能在队尾插入元素,只能在队首删除元素队列的一些性质: 1.出队方案唯一 2.队首元素先出 3.新元素插入队尾 线性队列的初始化: #include using namespace std; class Queue{ private: int *data;
  • (一)循环队列

    2015-03-05 22:55:41
    所谓循环队列,是指当尾指针超过数组索引界限时,通过取余运算返回数组起始端,只要保证尾指针和头指针不相遇,就可以继续存储元素。 首先设定队列的大小,并建立队列结构体: #define MAXSIZE 100001 typedef ...
  • 循环队列问题

    千次阅读 2014-06-05 16:31:35
    1. 一循环队列,队头指针为front,队尾指针为rear,循环队列长度为N,其队内有效长度为_______ 2.
  • c ++stl队列使用To print all elements of a ... 要打印Queue的所有元素,请执行以下步骤: Run a loop till "queue is not empty". 循环运行直到“队列不为空” 。 Print the first (oldest) element by using que...
  • 循环队列 swustoj

    2018-04-19 20:30:30
    循环队列 1000(ms) 10000(kb) 2347 / 6268根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。例如,给定5个元素空间构造循环队列,则只能存放4个元素。试根据入队及出队操作判断队列最后的...
  • 循环队列(Circular Queue)

    千次阅读 2016-05-28 18:09:41
    为了能够充分地使用数组中的存储空间,克服”假溢出”现象,可以把数组的前端和后端连接起来,形成一个环形的表,即把存储队列元素的表从逻辑上看成一个环,成为循环队列(circular queue)。 1.2 循环队列中各元素的...
  • 循环队列及C语言实现<一>

    千次阅读 2016-09-21 22:34:11
    循环队列是为了充分利用内存,进行数据操作的一种基本算法。具体实现方式可划分为:链式队列和静态队列,这里所谓的静态是指在一片连续的内存区域进行数据操作。本文只讲述静态队列,也是最简单的实现方式,静态队列...
  • 队列只允许在表的一端进行插入(入队)、删除(出队)操作。允许插入的一端称为队尾,允许删除的一端称为队头。 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp;队列的基本操作包括: 初始化...
  • SWUST.OJ 965: 循环队列

    2020-05-04 10:27:56
    根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。例如,给定5个元素空间构造循环队列,则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即...
  • 编写一个程序,实现顺序循环队列的各种基本运算,完成如下功能 (1) 初始化队列 (2) 判断队列是否为空 (3) 依次进队元素a, b, c,d (4) 出队一个元素输出元素 (5) 输出队列的元素个数 (6) 依次进队列...
  • 数组实现循环队列

    2021-01-22 22:18:30
    循环队列 在实际使用队列时,为了使队列空间能重复使用,往往对队列的使用方法稍加改进:无论插入或删除,一旦rear指针增1或front指针增1 时超出了所分配的队列空间,就让它指向这片连续空间的起始位置。可以解决假...
  • 循环队列(965)

    2018-06-27 21:43:43
    根据给定的空间构造顺序循环队列,规定队满处理方法为少用一个元素空间。例如,给定5个元素空间构造循环队列,则只能存放4个元素。试根据入队及出队操作判断队列最后的元素存放情况,并输出最后队列中的元素值,即...
  • 循环队列的基本操作-C语言

    千次阅读 多人点赞 2019-06-24 11:54:45
    循环队列的基本操作一、循环队列二、循环队列的理解 一、循环队列 为充分利用向量空间,克服上述“假溢出”现象的方法是:将为队列分配的向量空间看成为一个首尾相接的圆环,并称这种队列为循环队列(Circular Queue)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,462
精华内容 30,984
关键字:

循环队列输出所有元素