精华内容
下载资源
问答
  • 利用循环队列打印杨辉三角形
    千次阅读
    2020-11-11 20:44:43

    利用循环队列打印杨辉三角形
    首先需要掌握的是循坏队列的基本函数
    1:初始化
    2:入队
    3:出队
    其次需要明确打印的循坏嵌套
    最后将代码整合在一起

    #include<stdio.h>
    #include<stdlib.h>
    #define MAXSIZE 100
    
    //循坏队列的存储结构定义 
    typedef struct 
    {
    	int data[MAXSIZE];
    	int front;//队首下标 
    	int rear;//队尾下标 
    } Queue;
    
    //初始化操作
    void InitQueue (Queue *q)
    {
    	q->front = q->rear = 0;//将队首队尾下标都赋值为0 
     } 
     
    //入队
    int pushQueue (Queue *q , int e)
    {
    	if((q->rear+1)%MAXSIZE == q->front) //损失一个元素的空间,尾指针所指向的空单元的后继单元是头所在的单元
    	{                                  //队列为满的条件:(rear+1)%MAXSIZE == front  
    		printf("队列已满不能入队!\n") ;
    		return 0 ;
    	}
    	else 
    	q->data[q->rear] = e; //元素从队尾进入队列 
    	q->rear = (q->rear+1)%MAXSIZE ; //入队:尾追头 
    	return 1 ;
     } 
     int popQueue(Queue *q,int &x)//这里需要将参数x值改变带回来,所以需要用引用或者指针 
     {
     	if(q->front==q->rear)
     		printf("队列为空!\n");
     		return 0;
     		x=q->data[q->front];//元素从队首位置出队列 
     		q->front=(q->front+1)%MAXSIZE;
    		return 1;	 
     }
    
     
    
     void YangHuiTriangle(int N)
     {
     	Queue q;
     	//q=new Queue();
     	int i,j,k,s1,s2,s,x;
     	InitQueue(&q);
     	for(k=1;k<=N;k++)
     		printf(" ");//打印第一行的空格 
     	printf("%d",1);//打印第一行的元素 
     	printf("\n");
     	pushQueue(&q,1);//将元素1入队 
     	for(i=2;i<=N;i++)//此层循坏控制着杨辉三角形的行数 
     	{
     		for(k=N-i;k>=0;k--)
     			printf(" ");// 打印第i行的空格 
    		s1=0;
    		for(j=1;j<=i-1;j++)//控制第i行中的元素 
    		{
    			popQueue(&q,s2);//将队列队首的元素出队。赋值给s2 
    			s=s1+s2;//控制前一行的元素相加 
    			pushQueue(&q,s);//将得到的结果s入队 
    			printf("%d",s);//打印s 
    			printf(" ");//设置打印后的空格 
    			s1=s2; 
    		} 
    		printf("%d",1);//打印第i行的最后一个元素 
    		pushQueue(&q,1);//将1重新入队 
    		printf("\n");
    	 }
     }
     //主函数 
     int main()
     {
     	int N;
     	printf("请输入杨辉三角形的行数:");
    	scanf("%d",&N);
    	YangHuiTriangle(N);//调用打印杨辉三角形的函数 
    	return 0;
     }
    
    更多相关内容
  • 循环队列 杨辉三角

    2014-05-19 17:58:08
    queue.h头文件:循环队列的实现,操作包括初始化队列、入队、检查是否为空、出队、检查是否为满。源.cpp:利用两个队列打印出杨辉三角
  • 循环队列实现杨辉三角的输出。通过该程序可以让你对循环队列有一定的理解。
  • 循环队列实现杨辉三角形

    千次阅读 2020-05-28 22:57:09
    最近在上数据结构与算法,...首先先创建一个循环队列: typedef struct sq { int a[MAXSIZE];//队列元素空间 int front,rear;//队头和队尾指针 }*SeqQue; SeqQue InitQue() { SeqQue q; q=(SeqQue)malloc(sizeof

    最近在上数据结构与算法,期末老师要求同学抽问题,然后写这个算法问题的实验报告;其中就包含了用队列来实现杨辉三角形,这里就先提前练下手,万一运气好我就刚好抽到这个呢了(好了,不开玩笑了,进入正题吧)

    算法思想:

    首先先创建一个循环队列:

    typedef struct sq
    {
     int a[MAXSIZE];//队列元素空间
     int front,rear;//队头和队尾指针
    }*SeqQue;
    
    SeqQue InitQue()
    {
     SeqQue q;
     q=(SeqQue)malloc(sizeof(sq));
     if(q==NULL)
     {
      cout<<"创建循环队列失败!"<<endl;
      return NULL;
     }
     q->front=q->rear=0;//设置队头和队尾指针初值为0
     return q;
    }

    其次实现这个算法只需用到入队(在队尾入队)和出队(在队头出队)操作,但其中的细节还是要抓,比如:判断队列是否为空或已满

    void enter(SeqQue q,int x)//入队函数
    {
     if((q->rear+1)%MAXSIZE==q->front)//判断队列是否已满
     {
      cout<<"循环队列已满!"<<endl;
      return;
     }
     q->a[q->rear]=x;
     q->rear=(q->rear+1)%MAXSIZE;//队尾指针加1
    }
    
    int OutQue(SeqQue q)//出队函数
    {
     int x;
     if(q->rear==q->front)//判断队列是否为空
     {
      cout<<"循环队列已空"<<endl;
      return 0;
     }
     x=q->a[q->front];//取出队头元素并返回
     q->front=(q->front+1)%MAXSIZE;//队头指针加1
     return x;
    }

    上面的队头和队尾指针有的博客可能不明白为什么要求模MAXSIZE,其实很简单,就是这是个循环队列,入队和出队函数运行了很多次,如果不求模MAXSIZE,队头和队尾指针可能就超过了MAXSIZE,并且求模后才是真正的队头和队尾指针。

    下面才是这个算法的核心:
    1>将第一行的元素1入队;
    2>从第二行开始,现在的队头指向上一行,先将每行的固定元素1入队,然后循环操作求和过程:(将队首元素出队,并保存它的值为t1;获取当前队首的元素的值为t2,并进行x=t1+t2,且将x入队)
    3>循环结束后,每行最后输出固定元素1,然后将x赋值为1,并将每行的最后一个固定元素1入队;
    4>循环2、3步就可以输出杨辉三角形了。

    核心代码如下:

     SeqQue q;
     int x=1,i;
     cout<<"请输入杨辉三角形打印的行数:"<<endl; 
     cin>>i;
     q=InitQue();//创建一个初始化循环队列
     for(int n=0;n<i;n++)
     {
         for(int m=0;m<i-1-n;m++)
         {
          cout<<" ";
         }
         if(n==0)
         {
         cout<<1<<endl;
         enter(q,x);
         }
         else
         {
            int t1=0,t2=0;//方便队首元素的保存和获取
            for(int r=0;r<n;r++)
            {
             t1=t2;//保存上一个队首元素的值
             t2=OutQue(q);//获取当前队首元素的值
             x=t1+t2;//保证x是等于上一行它的左边元素和右边元素(位置)的和
             enter(q,x);//将求和的值入队,用于下一行元素的计算
             cout<<x<<" "; 
            }
            cout<<1<<endl;
            x=1;
            enter(q,x);//将每行的最后一个固定元素1入队
          } 
     }

    其实你仔细调试代码后,就会发现每执行完一次大循环,循环队列中的元素就是对应的那一行元素的值:上一次循环队列的元素出队,当前对应的杨辉三角形这行元素入队。

    AC代码如下:

    #include <iostream>
    using namespace std;
    #define MAXSIZE 500
    
    typedef struct sq
    {
     int a[MAXSIZE];
     int front,rear;
    }*SeqQue;
    
    SeqQue InitQue()
    {
     SeqQue q;
     q=(SeqQue)malloc(sizeof(sq));
     if(q==NULL)
     {
      cout<<"创建循环队列失败!"<<endl;
      return NULL;
     }
     q->front=q->rear=0;
     return q;
    }
    
    void enter(SeqQue q,int x)
    {
     if((q->rear+1)%MAXSIZE==q->front)
     {
      cout<<"循环队列已满!"<<endl;
      return;
     }
     q->a[q->rear]=x;
     q->rear=(q->rear+1)%MAXSIZE;
    }
    
    int OutQue(SeqQue q)
    {
     int x;
     if(q->rear==q->front)
     {
      cout<<"循环队列已空"<<endl;
      return 0;
     }
     x=q->a[q->front];
     q->front=(q->front+1)%MAXSIZE;
     return x;
    }
    
    int main()
    {
     SeqQue q;
     int x=1,i;
     cout<<"请输入杨辉三角形打印的行数:"<<endl; 
     cin>>i;
     q=InitQue();
        for(int n=0;n<i;n++)
        {
         for(int m=0;m<i-1-n;m++)
         {
          cout<<" ";
         }
         if(n==0)
         {
         cout<<1<<endl;
         enter(q,x);
         }
         else
         {
            int t1=0,t2=0;
            for(int r=0;r<n;r++)
            {
             t1=t2;
             t2=OutQue(q);
             x=t1+t2;
             enter(q,x);
            cout<<x<<" "; 
           }
           cout<<1<<endl;
           x=1;
           enter(q,x);
        } 
       }
     return 0;
    }

    最后我觉得我的数据结构老师这学期讲不完这门课了,可以请各位大佬出些关于算法的干货吗 嘻嘻。。。

    展开全文
  • C语言-循环队列输出金字塔型杨辉三角

    杨辉三角规律图

     1.静态规律图

     

     2.动态规律图

     

    代码实现

    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    #define MAXQSIZE 200
    
    typedef struct {
        int  *base;
        int front;
        int rear;
    }Queue;
    
    //初始化队列 
    void initQueue(Queue &Q){
        Q.base=(int *)malloc(MAXQSIZE*sizeof(int));
        Q.front=Q.rear=0;
    }
    
    //队列长度 
    int length(Queue &Q){
        return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
    }
    
    //入队列
    void inQueue(Queue &Q,int e){
        if((Q.rear+1)%MAXQSIZE ==Q.front) exit(1);//队列满了 
        Q.base[Q.rear]=e;
        Q.rear=(Q.rear+1)%MAXQSIZE;
    }
    
    //出队列 
    void outQueue(Queue &Q,int &e){
        e=Q.base[Q.front];
        Q.front=(Q.front+1)%MAXQSIZE;
    }
    
    int getHead(Queue &Q){
        return Q.base[Q.front];
    }
    int main(){
        int N,n,c,i;
        int t,x;
        Queue f,Q;
        initQueue(Q);
        printf("请输入要打印的杨辉三角函数,不建议过大以获得良好效果:\n");
        scanf("%d",&N);
        inQueue(Q,1);
        for(n=2;n<=N+1;n++){
        	inQueue(Q,1);
            for(int j = 0; j < N-n+1;j++){ 
                printf("   ");
            }
            for(c=1;c<=n-2;c++){
                t=getHead(Q);
                outQueue(Q,t);
                printf("%6d",t);
                x=getHead(Q);
                t=t+x;
                inQueue(Q,t);  
            }
            inQueue(Q,1);
            printf("%6d",getHead(Q));
            outQueue(Q,t);
            printf("\n");
        }
        while(Q.front!=Q.rear){
            printf("%3d",getHead(Q));
            printf("   ");
            outQueue(Q,t);
        }
        printf("\n");
        return 0;
    }

    运行结果

     

    展开全文
  • 循环队列实现杨辉三角(两种输出形式)

    千次阅读 多人点赞 2020-03-30 16:51:39
    问题导入什么是杨辉三角呢?之前用过C/C++数组实现过打印杨辉三角,那么如何使用队列来实现呢?

    问题导入什么是杨辉三角呢?之前用过C/C++数组实现过打印杨辉三角,那么如何使用队列来实现呢?

    1、什么是杨辉三角

    杨辉三角(也称帕斯卡三角)相信很多人都不陌生,它是一个无限对称的数字金字塔,从顶部的单个1开始,下面一行中的每个数字都是上面两个数字的和。

    1.1 图形

    下图就是杨辉三角前7行
    前7行杨辉三角

    1.2 特点

    杨辉三角的实质是二项式(a+b)n展开后各项的系数排成的三角形。

    特点如下:
    	1、各行的第一个数都是1
    	2、各行的最后一个数都是1
    	3、从第3行起,除上面指出的第一个数和最后一个数外,其余各数是上一行同列和前一列两个数之和。
    

    2、什么是队列

    2.1 队列的定义

    队列(queue)是一种先进先出(First In First Out, FIFO) 的线性表。它只允许在表的一端进行插入,而在另一端删除元素。这和日常生活中的排队是一致的,最早进入队列的元素最早离开。在队列中,允许插入的一端称为队尾(rear),允许删除的一端则称为队头(front)。
    队列的示意图

    2.2 队列的常用公式

    一般使用循环队列(提高空间的利用率)

    初始化:				Q.front = Q.rear = 0;
    入队操作:			Q.rear=( Q.rear+1 )%MaxQueueSize;
    出队操作:			Q.front=( Q.front+1 )%MaxQueueSize;
    判断队空:			Q.front = Q.rear;
    判断队满:			( Q.rear + 1 ) % MaxQueueSize == Q.front;
    计算队列长度:		( Q.rear - Q.front + MaxQueueSize ) % MaxQueueSize;
    

    3、队列实现杨辉三角原理

    3.1 图形演示

    • 第i行元素与第i+1行元素的关系示意图:
      在这里插入图片描述

    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200330154455422.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0NDg3MjYz,size_16,color_FFFFFF,t_7

    原理是打印每行系数元素,每行之间用0间隔开来。

    • 从第i行的数据出队并计算出第i+1行的数据入队的示意图:
      从第i行的数据出队并计算出第i+1行的数据入队的示意图:
      从第三行开始,除每行首末元素外,第i+1行每个元素都为第i行同列和前一列两个数之和,以此类推,第i行一个系数出队,计算第i+1行系数,并入队。

    3.2 主要算法实现

    EnQueue(Q , 0);				//各行间插入一个0
    for(j = 1; j <= i+2; j++){
    	DeQueue(Q , t);			//一个系数出队
    	EnQueue(Q , s+t);		//计算下一行系数,并入队
    	s = t;
    	if(j != i+2)
    		printf("%d" , s);	//第 i+2 个 0
    }
    

    4、代码实现

    4.1 main.cpp

    //使用队列输出杨辉三角
    #include<stdio.h>
    #include<stdlib.h>
    #define MAXQSIZE 1000000//队列可达到的最大长度
    #define OVERFLOW -1
    #define ERROR 0
    #define OK 1
    typedef int QElemType;
    typedef int Status;
    typedef struct {
    	QElemType *base;//定义队列指针
    	int front;		//头指针
    	int rear;		//尾指针
    } SqQueue;
    
    //初始化
    Status InitQueue(SqQueue &Q) {
    	Q.base = new QElemType[MAXQSIZE];//为队列分配一个最大容量为MAXQSIZE的数组空间
    	if(!Q.base) exit(OVERFLOW);  	//存储分配失败
    	Q.front = Q.rear = 0;     		//头指针和尾指针置为零,队列为空
    	return OK;
    }
    
    //入队
    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;
    }
    
    //出队
    Status DeQueue(SqQueue &Q, QElemType &e) {//删除Q的对头元素,用e返回其值
    	if (Q.front == Q.rear)
    		return ERROR;                   //队空
    	e = Q.base[Q.front];                //保留对头元素
    	Q.front = (Q.front + 1) % MAXQSIZE;//对头指针加1
    
    	return OK;
    }
    
    //取对头元素
    Status GetHead(SqQueue &Q, QElemType &e) {
    	if (Q.front == Q.rear)
    		return ERROR;                    //队空
    	e = Q.base[Q.front];                //保留对头元素
    	return OK;
    
    }
    
    //判断队列是否为空
    int IsEmpty(SqQueue &Q) {
    	if (Q.rear == Q.front)//队空
    		return OK;
    	else
    		return ERROR;
    }
    
    //创建杨辉三角,N表示三角形的行数
    void YHTriangle(int n){
    	int i,j,s=0,t=0;
    	SqQueue Q;          		//定义队列Q
    	InitQueue(Q);               //初始化队列
    	EnQueue(Q,1);
    	EnQueue(Q,1);               //第一行元素入队 1 1
    	for(i = 1;i < n;i++){
    		EnQueue(Q,0);           //各行间插入一个0
    		for(j = 1;j <= i+2;j++){
    			DeQueue(Q,t);       //一个系数出队
    			EnQueue(Q,s+t);     //计算下一行系数,并入队
    			s = t;
    			if(j!=i+2){
    				printf("%d ",s);//第i+2个0
    			}
    		}
    		//输出形式,二选一
    		printf("0 ");           //输出一维数组,每行用0间隔
    		printf("\n");           //输出杨辉三角形
    	}
    }
    
    //主函数
    int main() {
    	int N;
    	printf("请输入杨辉三角行数 N : ");
    	scanf("%d", &N);
    	YHTriangle(N);			//调用杨辉三角函数
    	return 0;
    }
    

    4.2 运行结果

    4.2.1按杨辉三角形打印

    YHTriangle() 函数中最后的一行 为printf("\n");

    请输入杨辉三角行数 N : 10
    1
    1 1
    1 2 1
    1 3 3 1
    1 4 6 4 1
    1 5 10 10 5 1
    1 6 15 20 15 6 1
    1 7 21 35 35 21 7 1
    1 8 28 56 70 56 28 8 1
    1 9 36 84 126 126 84 36 9 1
    
    4.2.2 按一维数组方式打印一行

    YHTriangle() 函数中最后的一行 为printf("0 ");

    请输入杨辉三角行数 N : 10
    1 0 1 1 0 1 2 1 0 1 3 3 1 0 1 4 6 4 1 0 1 5 10 10 5 1 0 1 6 15 20 15 6 1 0 1 7 21 35 35 21 7 1 0 1 8 28 56 70 56 28 8 1 0 1 9 36 84 126 126 84 36 9 1 0
    

    注:部分图片源自教材和教学PPT;
    部分名词已链接百度百科,可以进行更详细的阅读。

    展开全文
  • 如果要求计算并输出杨辉三角前 n 行的值,;‘则队列的最大空间应为 n+2。假设队列中已存有第 k 行的计算结果,并为了计算方便,在两行之间添加一个“0”作为行界值,则在计算第 k+1 行之前,头指针正指向第 k 行的...
  • =self.front: self.rear=(self.rear+1)%self.MaxQueueSize self.s[self.rear]=x else: print("队列已满") return def DeQueue(self): if self.IsEmptyQueue(): print("队列为空") return else: self.front=(self....
  • 【问题描述】杨辉三角形是由〖(a+b)〗n二项式展开的各项系数形成的,当n=0,系数为1,生成第一行的元素;...请利用队列打印杨辉三角形前n行元素。 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 1 6
  • 循环队列应用之杨辉三角(C语言)

    千次阅读 2019-09-24 23:18:19
    杨辉三角是什么不多赘述。直接上代码。 只用到四个函数:init、inset、delete、get。这一部分是老套路。 #include<stdio.h> #include<stdlib.h> #define MAXQSIZE 100 typedef int elemtype; ...
  • 主要的功能:1)循环队列的初始化 2)求循环队列的长度 3)循环队列的插入删除操作 4) 判断循环队列是否为空,是否已经满了 5)遍历循环队列 杨辉三角形
  • 如果要求计算并输出杨辉三角前N行的值,则队列的最大空间应为n+2(第N行有n+1个数,且根据循环队列的特性:“少用一个元素”,但在这里少用的那个元素用来存放临界值“0”)。#include"QueueSq.cpp"void ...
  • 循环队列实现杨辉三角及数据结构

    千次阅读 2016-04-24 16:43:42
    数据结构顺序,链式实现栈和队列的相关操作,并用循环队列实现杨辉三角。1.采用链式存储实现栈的初始化、入栈、出栈操作。 链式栈中首先确定栈底指针,再入栈,并移动栈顶指针。#include #include #include #...
  •  // 定义错误类型代码,以便调用函数时用 cout请输出要打印杨辉三角的行数:"; cin>>n; cout(1); // 所输出的1入队 for(i=2; i; i++) // 依次计算并输出第2~i行上的数据 { s1=0; // 存放前一个出队的数 for(j=1...
  • 用循环队的方式处理杨辉三角形问题(C++) ...//循环队列 typedef struct { int data[MAX]; int front; //头指针 int rear; //尾指针 } SeqQueue; //初始化循环队列 void InitQueue(SeqQueue *&q)
  • 4-2 用循环队列打印杨辉三角形 杨辉三角形是由(a+b)^n二项式展开的各项系数形成的,当n=0,系数为1,生成第一行的元素;当a=1,a+b的各项系数组成第二行的元素;当n=2,a^2+2ab+b^2的各项系数组成第三行的元素,...
  • /*利用循环链表打印杨辉三角算法逻辑 *第一步先将第一行的1输出 *将第二行 的两个1进行入队操作 *从第二行开始 先将下一行的第一个元素1入队 *进入第二个循环将第i行的第一个元素出队 并得到第二个元素的值 *然后将...
  • 利用循环队列打印杨辉三角(c语言实现)

    万次阅读 多人点赞 2018-08-29 16:01:22
    "请输入杨辉三角规模:\n" ); scanf ( "%d" ,&N); EnQueue(Q, 1 ); for (n= 2 ;n;n++){ EnQueue(Q, 1 ); for (c= 1 ;c 2 ;c++){ t=GetHead(Q); DeQueue(Q); printf ( "%4d" ,t); x=GetHead(Q); t=t+x; ...
  • 杨辉三角,是二项式系数在三角形中的一种几何排列。在欧洲,这个表叫做帕斯卡三角形。帕斯卡是在1654年发现这一规律的,比杨辉要迟393年,比贾...这里我们用c++的结构体和循环队列来进行编译: 定义结构体: typedef st
  • #生成器生成展示杨辉三角 #原理是在一个2维数组里展示杨辉三角,空的地方用0,输出时,转化为' ' def yang(line): n,leng=0,2*line - 1 f_list = list(range(leng+2)) #预先分配,insert初始胡会拖慢速度,最底下...
  • 数据结构 实验报告 项目名称 栈队列杨辉三角 专业班级 软件工程工科试验班 学 号 3903120128 姓 名 谢江 实验成绩 批阅教师 2012年 5月 22 日 实验1单链表的建立与约瑟夫问题 实验学时 实验地点 寝室与实验室 实验...
  • 该C程序使用循环队列实现了N行杨辉三角的输出,实现简单。 使用VC进行编译即可。
  • class SeqQueue //循环队列的类定义 { public: SeqQueue(){ maxSize=50; element=new T[maxSize]; front=0; rear=0; } ~SeqQueue(){delete[] element;} //析构函数 bool EnQueue(const T& x); //若队列不满,则将x...
  • 杨辉三角形又称Pascal三角形,它的第i+1行是(a+b)i的展开式的系数。它的一个重要性质是:三角形中的每个数字等于它两肩上的数字相加。   下面给出了杨辉三角形的前4行: 1  1 1  1 2 1  1 3 3 1 给出n,输出...
  • 杨辉三角形是形如:111121133114641使用《队列》的思想来实现杨辉三角的流程:1>首先,需要初始化一个队列,即对头=队尾=0;2>将第一行的元素1入队,接着操作第二行(一二行不需要求和操作,直接将元素入队即可...
  • 数据结构课后作业,自己写的,用队列的方法打印杨辉三角
  • 利用循环队列打印杨辉三角 /* ******************************** 利用循环队列打印杨辉三角前N行的值(N <= 7), 并以金字塔的形式输出相应的值。 **********************************/ #include <stdio.h>...
  • 循环队列解决杨辉三角

    千次阅读 2015-12-04 12:16:22
    循环队列解决杨辉三角#include #include <stdlib.h>#define Maxsize 10typedef struct NODE { int data[Maxsize]; int rear; int front; }CqQueue, *Cqlist;/* 函数功能:队列的初始化 */ Cqlist InitCQ
  • // 循环队列队列的顺序存储结构 #include<stdio.h> #include<malloc.h> #include<process.h> //exit 的头文件 #define OK 1 #define ERROR 0 #define MAXQSIZE 100// 最大队列长度 #define Status int #define N 10 ...

空空如也

空空如也

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

循环队列杨辉三角