杨辉三角队列实现

合集下载

c语言杨辉三角形代码

c语言杨辉三角形代码杨辉三角形是中国古代数学中较为重要的数学问题之一，也是计算机领域中经典的问题之一。

它形成一个三角形，数字排列成三角形形状，其中每个数字等于它上方两数字之和。

以下是一个用C语言编写的杨辉三角形代码：#include <stdio.h>int main() {int rows, coef = 1;printf("请输入行数: ");scanf("%d", &rows);for (int i = 0; i < rows; i++) {for (int space = 1; space <= rows - i; space++)printf(" ");for (int j = 0; j <= i; j++) {if (j == 0 || i == 0)coef = 1;elsecoef = coef * (i - j + 1) / j;printf("%4d", coef);}printf("\n");}return 0;}在这个代码中，我们首先定义一个整数变量rows来表示杨辉三角形的行数。

然后通过用户输入来获取杨辉三角形的行数。

接着我们使用两个嵌套循环来打印杨辉三角形。

外层循环用来控制打印的行数。

内层循环用来打印每一行的数字。

在内层循环中，首先使用一个循环打印空格，使得每行的数字能够居中显示。

其次，在这个循环中，我们使用一个if语句来判断当前位置是否为杨辉三角形的边界，也就是第一个数字和每一行的最后一个数字。

如果是边界上的数字，我们将其设置为1，否则就使用前一行的数字通过组合公式计算当前位置的数字。

最后我们在内层循环的末尾打印一个换行符，以便换行显示下一行。

运行以上代码，将会看到打印出指定行数的杨辉三角形。

这个代码是很简单但有效的实现了杨辉三角形的打印。

python实现杨辉三角的几种方法代码实例

python实现杨辉三⾓的⼏种⽅法代码实例⽅法⼀：迭代def triangle_1(x):""":param x: 需要⽣成的杨辉三⾓⾏数:return:"""triangle = [[1], [1, 1]] # 初始化杨辉三⾓n = 3 # 从第三⾏开始计数,逐⾏添加while n <= x:for i in range(0, n-1):if i == 0:# 添加初始列表[1,1],杨辉三⾓每⾏的⾸位和末位必为1triangle.append([1, 1])else:# 逐位计算，并插⼊初始列表中triangle[n-1].insert(i, triangle[n - 2][i] + triangle[n - 2][i - 1])n += 1return trianglex = 11triangle = triangle_1(x)# 遍历结果，逐⾏打印for i in range(x):print(' '.join(str(triangle[i])).center(100)) # 转为str,居中显⽰⽅法⼆：⽣成器def triangle_2(n):""":param n: 需要⽣成的杨辉三⾓⾏数:return:"""triangle = [1] # 初始化杨辉三⾓for i in range(n):yield triangletriangle.append(0) # 在最后⼀位加个0，⽤于计算下⼀⾏triangle = [triangle[i] + triangle[i - 1] for i in range(len(triangle))]# 从⽣成器取值for i in triangle_5(10):print(''.join(str(i)).center(100)) # 格式化输出⽅法三：递归杨辉三⾓特性：【1，1】=【0，1】+【1，0】【1，2，1】=【0，1，1】+【1，1，0】【1，3，3，1】=【0，1，2，1】+【1，2，1，0】【1，4，6，4，1】=【0，1，3，3，1】+【1，3，3，1，0】第n⾏等于第n-1⾏分别⾸尾补0，然后按位相加def triangle_4(n):""":param n:需要⽣成的杨辉三⾓⾏数:return:"""triangle = [1] # 初始化杨辉三⾓if n == 0:return trianglereturn [x+y for x, y in zip([0] + triangle_4(n - 1), triangle_4(n - 1) + [0])]for i in range(10):print(''.join(str(triangle_4(i))).center(100))到此这篇关于python实现杨辉三⾓的⼏种⽅法代码实例的⽂章就介绍到这了,更多相关python实现杨辉三⾓内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

用队列方法输出杨辉三角

/*用队列方法输出杨辉三角。

*/#include<iostream.h>#include<iomanip.h>#include<stdlib.h>#define ElemType int/*-----LNode的结点类型定义-----*/struct LNode{ElemType data; //值域LNode* next; //链接指针域};/*-----队列的链接存储结构的定义-----*/struct LinkQueue{LNode* front; //队首指针LNode* rear; //队尾指针};/*------1.初始化链队-----*/void InitQueue(LinkQueue& HQ){HQ.front=HQ.rear=NULL; //把队首和队尾指针置为空}/*-----2.向链队中插入一个元素------*/void EnQueue(LinkQueue& HQ, ElemType item){LNode* newptr=new LNode; //得到一个新的结点newptr->data=item; //把item 的值赋给新结点的值域newptr->next=NULL; //把新结点的指针域置为空if(HQ.rear==NULL) //若链队为空，则新结点既是队首又是队尾{HQ.front=HQ.rear=newptr;}else //若链队非空，则新结点被链接到队尾并修改队尾指针{HQ.rear=HQ.rear->next=newptr;}}/*-------3.从队列中删除一个元素-------*/ElemType OutQueue(LinkQueue& HQ){if(HQ.front==NULL) //若链队为空则终止运行{cerr<<"链队为空，无法删除！"<<endl;exit(1);}ElemType temp=HQ.front->data; //暂存队首元素以便返回LNode* p=HQ.front; //暂存队首指针以便收回队首指针HQ.front=p->next; //使队首指针指向下一个结点if(HQ.front==NULL) //若删除后链队为空，则使队尾指针为空{HQ.rear=NULL;}delete p; //回收原队首结点return temp; //返回被删除的队首元素}void YanyHuiTriangular(LinkQueue& HQ, int n){int i,j; //i，j 都是循环变量int first,second; //first,second 分别记录上一行的两个累加数EnQueue(HQ,1);for(i=1; i<n+1; i++){ //第 0 至 n-1 行元素分别入列，并输出；最后第 n 行入列first=0; second=0;//控制每行前头空格的输出for(j=0; j<n-i+1; j++){cout<<setw(3)<<' ';}for(j=0; j<i; j++){second=OutQueue(HQ);cout<<setw(3)<<second<<setw(3)<<' ';EnQueue(HQ,first+second);first=second;}cout<<endl; //输完一行，回车EnQueue(HQ,second);}//最后输出最后一行元素（即第 n 行出列）for(j=0; j<n+1; j++){cout<<setw(3)<<OutQueue(HQ)<<setw(3)<<' '; }cout<<endl;}void main(){LinkQueue LQ;InitQueue(LQ);cout<<"用队列输出杨辉三角!"<<endl<<endl; int n;cout<<"请输入要输出多少行杨辉三角："; cin>>n;YanyHuiTriangular(LQ,n);}。

c++杨辉三角形程序的原理

c++杨辉三角形程序的原理（最新版）目录1.C++杨辉三角程序的原理2.杨辉三角的定义和特点3.C++程序实现杨辉三角的原理4.具体的 C++代码示例正文C++杨辉三角程序的原理杨辉三角是一个二维数组的三角形，其特点是每个数字是它左上方和右上方的两个数字之和。

因此，它可以看作是一组斐波那契数列的排列。

在 C++中，我们可以通过循环和条件语句来实现杨辉三角的生成。

杨辉三角的定义和特点杨辉三角是一个二维数组，其形状像一个三角形。

它的特点是每个数字是它左上方和右上方的两个数字之和。

例如，如果杨辉三角的阶数为 4，那么它的第一个数字是 1，第二个数字是 1，第三个数字是 2，第四个数字是 3，第五个数字是 5，以此类推。

C++程序实现杨辉三角的原理在 C++中，我们可以通过循环和条件语句来实现杨辉三角的生成。

具体来说，我们可以使用嵌套循环来遍历二维数组，并根据条件语句来计算每个数字的值。

例如，我们可以使用以下代码来实现杨辉三角的生成：```c++#include <iostream>using namespace std;int main() {int n = 5; // 指定杨辉三角的阶数int triangle[n][n]; // 定义二维数组来存储杨辉三角// 遍历二维数组并计算每个数字的值for (int i = 0; i < n; i++) {for (int j = 0; j < n - i - 1; j++) {triangle[i][j] = triangle[i - 1][j] + triangle[i - 1][j + 1];}}// 输出杨辉三角for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {cout << triangle[i][j] << " ";}cout << endl;}return 0;}```具体的 C++代码示例在上面的代码中，我们首先定义了一个指定杨辉三角阶数的变量 n，然后定义了一个二维数组来存储杨辉三角。

C语言杨辉三角两种实现方法

C语⾔杨辉三⾓两种实现⽅法⽬录杨辉三⾓——C语⾔实现⽅法⼀：利⽤⼆维数组实现⽅法⼆（对⽅法⼀的改进）：总结杨辉三⾓——C语⾔实现杨辉三⾓：在屏幕上打印杨辉三⾓。

11 11 2 11 3 3 1……根据上述例⼦可知：1.每⼀⾏的第⼀个和第⼆个数为1；2.其余的数为正上⽅和左边数字之和。

⽅法⼀：利⽤⼆维数组实现解题思路：根据杨辉三⾓的规律，我们可以定义⼀个⼆维数组来实现杨辉三⾓的打印，其中数字的规律为：data[i][j] = data[i - 1][j] + data[i - 1][j - 1]，所以我们按照这个⽅法将数据填⼊⼆维数组之后打印即可。

代码如下：#include <stdio.h>int main(){int n;int data[30][30] = {1};//将第⼀⾏直接填好，为1printf("请输⼊要打印的⾏数:>");scanf("%d", &n);for (int i = 1; i < n; i++)//从第⼆⾏开始填{data[i][0] = 1;//将每⼀⾏第⼀列先初始化为1，防⽌越界for (int j = 1; j < i + 1; j++){data[i][j] = data[i - 1][j] + data[i - 1][j - 1];}}for (int i = 0; i < n; i++)//打印⼆维数组{for (int j = 0; j < i + 1; j++){printf("%d ", data[i][j]);}printf("\n");}return 0;}运⾏结果：⽅法⼆（对⽅法⼀的改进）：由于我在填第n⾏的杨辉三⾓时，只跟第n-1⾏的杨辉三⾓产⽣联系，不会跟之前的有联系，所以没必要保存每⼀⾏的杨辉三⾓，利⽤⼀维数组，填⼀⾏打⼀⾏即可，这样能让空间复杂度从O(n^2)降低到O(n)。

数据结构实验报告(杨辉三角-约瑟夫环)

数据结构实验报告实验一杨辉三角形(Pascal’s triangle)一、需求分析1.输入的形式和输入值的范围本程序中，需输入的杨辉三角级数level为正整数，由键盘输入，以回车结束2.输出的形式通过屏幕输出杨辉三角3.程序所能达到的功能用户从键盘输入需要的杨辉三角级数，从屏幕输出杨辉三角4.测试数据输入：5输出： 1 11 2 11 3 3 11 4 6 4 11 5 10 10 5 1二、概要设计以链队列结构实现该实验1.抽象数据类型定义ADT Queue {数据对象：D = { ai | ai∈ElemSet , i = 1,2,…,n,n≥0 }数据关系：R1={<ai-1,ai> | ai-1 , ai∈D, i=2,…,n}约定其中ai端为队列头，an端为队列尾基本操作：InitQueue ( &Q )操作结果：构造一个空队列QDestroyQueue ( &Q )初始条件：队列Q已存在操作结果：队列Q被销毁，不再存在ClearQueue ( &Q )初始条件：队列Q已存在操作结果：将Q清为空队列QueueEmpty ( Q )初始条件：队列Q已存在操作结果：若Q为空队列，则返回TRUE，否则FALSEQueueLength ( Q )初始条件：队列Q已存在操作结果：返回Q的元素个数，即队列长度GetHead ( Q , &e )初始条件：Q为非空队列操作结果：用e返回Q的队头元素EnQueue ( &Q , e )初始条件：队列Q已存在操作结果：插入元素e为Q的新队尾元素DeQueue ( &Q , &e )初始条件：Q为非空队列操作结果：删除Q的队头元素，并用e返回其值QueueTraverse ( Q , visit( ) )初始条件：Q已存在且非空操作结果：从队头到队尾，依次对Q的每个数据元素调用函数visit( )。

循环队列实现杨辉三角形的打印

循环队列实现杨辉三⾓形的打印知识温习循环队列：即将顺序队列的数组看成是⼀个环状的空间，规定最后⼀个单元的后继为第⼀个单元。

运⽤循环队列可以有效的解决链队列的“假溢出”现象。

假溢出其实是指在链队列中，当rear==MAXSIZE时就认为队满。

然⽽由于元素的出队，使得数组前⾯出现⼀些空单元，⽽元素⼜只能在队尾⼊队，如果此时已经到数组的尾部，就认为队列已满，但其实还存在上述那些空单元未使⽤，队列并未真正满。

这种现象即为“假溢出”现象。

真正的队满条件应该是rear-front==MAXSIZE。

在循环队列中，我们通过数学中的求模运算来改变头指针和尾指针的位置。

进队操作时，队尾指针的变化是：rear=（rear+1）mod MAXSIZE；⽽出队操作时，队头指针的变化是：front=（front+1）mod MAXSIE。

杨辉三⾓形11 11 2 11 3 3 11 4 6 4 11 5 10 10 5 11 6 15 20 15 6 1从上图中可以看出，杨辉三⾓形的特点：每⾏的第⼀个元素和最后⼀个元素都为1，其他位置上的元素总是等于上⼀⾏与之相邻的两个元素之和。

故第i⾏的元素要由第i-1⾏的元素来⽣成。

可以利⽤循环队列实现杨辉三⾓形的打印过程：在循环队列中依次存放第i-1⾏上的元素，然后逐个出队并打印，同时⽣成第i⾏元素并⼊队。

下⾯⽤第6⾏元素⽣成第7⾏元素为例⼦来说明打印过程：①第7⾏的第⼀个元素1⼊队。

element[Q->rear] = 1;Q->rear = (Q->rear + 1)% MAXSIZE;②循环做以下操作，⽣成第7⾏的中间5个元素并⼊队。

element[Q->rear] = element[Q->front] + element[(Q->front+1)%MAXSIZE];Q->rear = (Q->rear + 1)%MAXSIZE;Q->front = (Q->front + 1)%MAXSIZE;③第6⾏的最后⼀个元素1⼊队。

队列实现杨辉三角的算法原理

队列实现杨辉三角的算法原理
杨辉三角是一种数学模式，每个位置上的数字等于它上方两个数字之和。

队列可以用来实现杨辉三角的算法，其原理如下：
1. 首先，创建一个空的队列。

2. 将1入队列，作为第一行的元素。

3. 进行循环，从第二行开始到第n行：
- 将当前队列中的元素依次出队，并将它们存储在一个临时数组temp中。

- 在temp数组末尾添加一个0，作为哨兵元素。

- 再将temp数组中的元素依次相加，并将结果入队列。

4. 打印队列中的元素，即可得到杨辉三角的结果。

这个算法的基本思路是利用队列先进先出的特性，每次处理一行的数据。

在处理每一行时，将队列中的元素依次出队，并计算它们的和，然后将和再次入队，作为下一行的元素。

通过不断重复这个过程，最终得到的队列中的元素就是杨辉三角的结果。

c语言-杨辉三角的两种输出方法

c语⾔-杨辉三⾓的两种输出⽅法c语⾔对杨辉三⾓的简单实现杨辉三⾓是数字与⼏何的完美融合，杨辉三⾓有着⾮常神奇的排列规律。

下⾯我们来复习以下杨辉三⾓形的特性，并⽤程序来输出杨辉三⾓形。

11 11 2 11 3 3 11 4 6 4 1如上，可以看出⼀个很简单的规律：每个数等于它上⽅两数之和。

每⾏数字左右对称，由1开始逐渐变⼤。

第n⾏的数字有n项。

利⽤这三个规律，我们可以⽤数组来实现杨辉三⾓的排列。

#include <stdio.h>#define N 14void main(){int i, j, k, n, arr[N][N]; /*定义⼆维数组arr[14][14]*/do{printf("请输⼊要打印的⾏数：");scanf("%d",&n);}while(n<=0||n>=N-1)； //对打印⾏数进⾏判断，避免越界for(i=1;i<=n;i++)a[i][1] = a[i][i] = 1; //两边的数令它为1，因为现在循环从1开始，就认为a[i][1]为第⼀个数for(i=3;i<=n;i++)for(j=2;j<=i-1;j++)a[i][j]=a[i-1][j-1]+a[i-1][j]; //除两边的数外都等于上⽅两数之和for(i=1;i<=n;i++){for(k=1;k<=n-i;k++)printf(" "); //对打印进⾏排版for(j=1;j<=i;j++)printf("%6d",a[i][j]);printf("\n");}return 0;}以上就是数组对杨辉三⾓的实现，如果不想使⽤数组还可以利⽤以下规律，进⾏直接打印。

第n⾏的m个数可表⽰为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。

杨辉三角形实验报告

题目：编写程序，根据输入的行数，屏幕显示杨辉三角形(Pascal’s triangle)班级：自动化05 姓名:刘丽丽学号：10054107 完成日期：2011.12.20 一．需求分析1、本演示程序中，利用顺序队列打印杨辉三角。

杨辉三角的特点是两个腰上的数字都为1，其它位置上的数字是其上一行中与之相邻的两个整数之和，故在打印过程中，第i行上的元素要由第i-1行中的元素来生成。

这是一个基于队列的操作来实现杨辉三角不断生成的过程。

2、此次输出的杨辉三角不需要只有一个1的第一行，但只需对输出实际杨辉三角的程序稍作修改即可；3、在计算机终端上显示"提示信息"之后，由用户在键盘上输入演示程序中需要输入的数据，以“回车符”为结束标志。

相应的输入数据和运算结果显示在其后。

4、程序执行的命令包括：1）构造顺序队列；2）分析第 i 行元素与第 i+1行元素的关系目的是从前一行的数据可以计算下一行的数据从第i 行数据计算并存放第i+1行数据5、测试数据输入行数 n=3；输出结果为：1 11 2 1 1 3 3 1二．概要设计链队列的抽象数据类型定义为： ADT Queue{ 数据对象：D={ai| ai ∈Elemset ，i=1,2,3，···n ，n ＞=0}11i = 1 1 2 121 3 3 13 14 6 4 141510 10 5 15 1 6152015 6 16数据关系：R={＜ai-1 ,ai＞| ai-1 ,ai∈D,i=1,2,···n} （约定其中ai端为队列头，an端为队列尾）基本操作：InitQueue（&Q）操作结果：构造一个空队列DestroyQueue（&Q）初始条件：队列已存在操作结果：队列被销毁ClearQueue（&Q）初始条件：队列已存在操作结果：将Q清空QueueEmpty（Q）若队为空，则返回为TRUE，否则返回为FALSE。

杨辉三角队列实现

杨辉三⾓队列实现杨辉三⾓显⽰问题描述：编写程序，根据输⼊的⾏数，屏幕显⽰杨辉三⾓。

基本要求：(1)⾏数不⼤于20⾏。

(2)基于队列的操作来实现杨辉三⾓的不断⽣成过程。

（注：不要⽤其它的公式计算的⽅法或者⼆维数组来实现）（3）基于数组实现队列的物理数据结构需求分析：1、输⼊形式：输⼊⼀个整数n ，0<=n<=202、输出形式：打印出来前(n+1)⾏的杨辉三⾓数列3、功能实现：输出前20层的杨辉三⾓序列4、样例输⼊输出：（数据加强版）输⼊：10输出：1 n=11 1 n=21 2 1 n=31 3 3 1 n=41 4 6 4 1 n=51 5 10 10 5 1 n=61 6 15 20 15 6 1 n=71 7 21 35 35 21 7 1 n=81 8 28 56 70 56 28 8 1 n=91 9 36 84 126 126 84 36 9 1 n=105、效率分析：O(n)抽象数据类型（ ADT）:抽象数据结构描述：Typedef struct {Int q[MaxSize];//存放队列中的元素Int front,rear;//front和rear分别是指向队头和队尾的指针}Queue;队列的基本操作：V oid InitQueue(Queue Q) function:构造⼀个空队列V oid EnQueue(Queue Q,int x) :function:将元素x⼊队V oid DeQueue(Queue Q,int x):function:删除队头元素，并⽤x返回其值Bool QueueEmpty(Queue Q) function:判断队列是否为空概要设计：既然要⽤到队列来打印杨辉三⾓，那么肯定会利⽤到队列FILO的性质（First In Lase Out），由于是要打印⼀个数列，那么肯定要利⽤已经进队的元素在其出队之前完成杨辉三⾓的递归性----即利⽤要出队的元素来不断地构造新的进队的元素，即在第N⾏出队的同时，我们来构造杨辉三⾓的第N+1⾏，从⽽实现打印杨辉三⾓的⽬的。

打印杨辉三角形C语言

{
if((Q->rear+1)%MAXSIZE==Q->front) //尾指针加1追上头指针，标志队列已经满了
return (false);
Q->element[Q->rear]=x;
Q->rear=(Q->rear+1)%MAXSIZE;//重新设置尾指针
return (true);
}
int Deleenttype *x)//出队操作
{
if(Q->front==Q->rear)
return true;
else
return false;
}
int GetHead(SeqQueue *Q,QueueElementtype *x)
{
if(!IsEmpty(Q))
{
*x=Q->element[Q->front];
return true;
}
}
while(!IsEmpty(&Q))
{
DeleteQueue(&Q,&x);
printf("%3d",x);
printf(" ");
}
printf("\n\n");
}
void main()//调用函数
{
YangHuiSanJiaoXing();
}
使用队列打印杨辉三角形
1.主要功能描述：
使用队列的入队，出队，获得头结点和判断是否为空等等，来实现对杨辉三角形的打印，第i行上的元素要由第i-1行中的元素来生成。
2.设计分析：由杨辉三角形的特点，即每一行的第一个元素和最后一个元素均为1，其他位置上的数字是其上一行中与之相邻的两个整数之和。所以第i行上的元素要由第i-1行中的元素来生成。

杨辉三角解析(队列实现)

for(i=1;i<=N;++i){for(j=0;j<30-3*i;++j)//打印每行前面的空格printf(" ");do{DeQueue();GetHead();if(e!=0) printf("%6d",e);EnQueue();}while(e!=0);UpQueue();puts("");//每行后回车换行}以n=4举例结果为：1 11 2 11 3 3 11 4 6 4 1解析：queue_size=n+2;//队列的最大容量queue_size=6（数组空间大小）for(i=0;i<n-2;++i) queue[i]=0;//初始化queue[i]=1,queue[i+1]=1,queue[i+2]=0;front=i-1,rear=n+1;初始化后的队列(queue数组)：front0 0 1 1 0rear打印第一行（即for（）循环中i=1）DeQueue(); 删除队首元素，并将0赋值s 实际只将front向下移一位，front=2，即指向queue[2] GetHead(); 取队首元素，e= queue[front]= queue[2]=1if(e!=0) printf("%6d",e); e！=0 打印e 即1继续执行do……while语句因为e不为0DeQueue(); 删除队首元素，并将queue[2]赋值s front=3GetHead(); 取队首元素，e= queue[front]=queue[3]=1if(e!=0) printf("%6d",e); e！=0 打印e 即1EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[0]=2 rear=1继续执行do……while语句因为e不为0DeQueue(); 删除队首元素，并将queue[3]赋值s front=4GetHead(); 取队首元素，e= queue[front]=queue[4]=0if(e!=0) printf("%6d",e); e==0 不执行printf（）语句EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[1]=1 rear=2此时e==0跳出do……while语句即打印第一行完毕输出： 1 1UpQueue(); 在队尾添加元素0 即queue[rear]=queue[2]=0 rear=3队列为：2 1 0 1 0 1puts("");//每行后回车换行rearfront打印第二行DeQueue(); s=0 front=5GetHead(); e=1if(e!=0) printf("%6d",e); e！=0 打印e 即1EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[3]=1 rear=4继续……DeQueue(); s=1 front=6 对queue_size取模即指向queue[0] front=0GetHead(); e=2if(e!=0) printf("%6d",e); e！=0 打印e 即2EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[4]=3 rear=5继续……DeQueue(); s=2 front=1GetHead(); e=1if(e!=0) printf("%6d",e); e！=0 打印e 即1EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[5]=3 rear=6对queue_size取模即指向queue[0] rear=0继续……DeQueue(); s=1 front=2GetHead(); e=0if(e!=0) printf("%6d",e); e==0 不打印EnQueue(); 在队尾添加元素s+e 此时queue[rear]=queue[0]=1 rear=1此时e==0跳出do……while语句即打印第二行完毕输出： 1 2 1UpQueue(); 在队尾添加元素0 即queue[rear]=queue[1]=0 rear=2队列为：……剩下依此类推……。

使用队列实现杨辉三角

使⽤队列实现杨辉三⾓使⽤队列实现杨辉三⾓杨辉三⾓的特点：除了第⼀⾏，其他⾏两端都为1；从第三⾏开始可以看出，除了两端，其中每个数都是元素本⾝上⾯对着的两个数的和；奇数⾏有奇数个数，偶数⾏有偶数个数，都是n个数每⾏数从左端开始看到中间都是升序，都是正序。

想要⽤代码来实现杨辉三⾓最简单的⽅法就是使⽤两个数组来实现，互相承载结果，并将数组打印出来。

但结合杨辉三⾓的特点，正序可以想到⽤队列的问题来解决。

解决⽅案：可以想到，作为开端的1可以看成是0和1的和，因此开始可以将队列设成这样（此处是以3⾏为例⼦）设定变量a和b来作为队列第⼀个元素和第⼆个元素的载体。

在a获取了第⼀个元素后将第⼀个元素移出队列，然后让b获取新的第⼀个元素，然后将a和b加起来，并将结果移进队列中，并将结果打印出来然后重复上述步骤，可以得到：要能够获取第⼆⾏的值，我在第⼀⾏中进⾏两次和运算即可，第⼀轮到此也就可以停⽌了。

然后，让⼀个0⼊列，再次重复上⾯的步骤，具体流程⼤概是这样：遇到的问题：最初的原代码：package ch15;import java.util.Scanner;/*** Created by Funny_One on 2017/10/13.*/public class YangHuiTriangle {public static void main(String[] args) {CircularArrayQueue<Integer> queue = new CircularArrayQueue();Scanner sca = new Scanner(System.in);System.out.println("需要显⽰的⾏数：");int n = sca.nextInt();queue.enqueue(0);queue.enqueue(1);System.out.println(1);for(int times =0;times<n;times++){queue.enqueue(0);for(int i=1;i<queue.size()-1;i++){int a,b=0,c;if(queue.size()==1){a = b;b = queue.first();c = a + b;queue.enqueue(c);System.out.print(c);}else {a=queue.first();queue.dequeue();b = queue.first();queue.dequeue();c = a+b;queue.enqueue(c);System.out.print(c+" ");}}System.out.println();}}}运⾏的结果是：可以见到，其中出现的问题有：问题1：每⼀⾏只有⼀个元素；问题2：每个元素都是1；问题3: 不只有三⾏；在我进⾏调试之后，发现这些问题的原因是：问题1的原因：在我的代码中，当a和b将数据获取之后，⼀个1⼊列，1被打印出来，同时两个数被移出队列。

数据结构之杨辉三角（队列实现）（C++版）

数据结构之杨辉三⾓（队列实现）（C++版）#include <iostream>#include <stdlib.h>#include <windows.h>#include <string>#define MAXLISTSIZE 100 //预设的存储空间最⼤容量#define TRUE 1#define FALSE 0using namespace std;typedef int ElemType;typedef struct{ElemType *elem; //存储空间基址 int rear; //队尾指针 int front; //队头指针int queuesize; //允许的最⼤存储空间，以元素为单位 }Queue;void InitQueue(Queue &Q, int maxsize){//构造⼀个最⼤存储空间为 maxsize 的空队列 Q if (maxsize == 0)maxsize = MAXLISTSIZE;Q.elem = new ElemType[maxsize]; //为循环队列分配存储空间 if (!Q.elem) exit(1); //存储分配失败Q.queuesize = maxsize;Q.front = Q.rear = 0;} //InitQueuebool EnQueue(Queue &Q, ElemType e){// 若当前队列不满，这在当前队列的尾元素之后，插⼊元素 e 为新的队列尾元素,并返回TRUE,否则返回FALSEif((Q.rear + 1) % Q.queuesize == Q.front)return FALSE;Q.elem[Q.rear] = e;Q.rear = (Q.rear+1) % Q.queuesize;return TRUE;}bool DeQueue(Queue &Q, ElemType &e){//若队列不空，则删除当前队列Q中的头元素，⽤ e 返回其值，并返回TRUE，否则返回 FALSE　if (Q.front == Q.rear)return FALSE;e = Q.elem[Q.front];Q.front = (Q.front+1) % Q.queuesize;return TRUE;}bool GetHead(Queue Q, ElemType &e){//若队列不空，则⽤ e 返回队⾸元素，并返回TRUE，否则返回 FALSEif (Q.front == Q.rear)return FALSE;e = Q.elem[Q.front];return TRUE;}int QueueLength(Queue Q){//返回队列Q中元素个数，即队列的长度return((Q.rear-Q.front+Q.queuesize) % Q.queuesize);}bool QueueEmpty(Queue Q){if(Q.front == Q.rear)return TRUE;elsereturn FALSE;}int main(void){//打印输出杨辉三⾓的前n(n>0)⾏int n, i, k;Queue Q;ElemType s, e;cout << "请输⼊杨辉三⾓的⾏数：";cin >> n;/* for(i = 1; i <= n; i++)cout << ' ';cout<< '1' << endl; // 在中⼼位置输出杨辉三⾓最顶端的"1"*/ InitQueue(Q, n+3); // 设置最⼤容量为 n+3 的空队列EnQueue(Q, 0); // 添加⾏界值EnQueue(Q, 1);EnQueue(Q, 1); // 第⼀⾏的值⼊队列k = 1;while(k < n){ // 通过循环队列输出前 n-1 ⾏的值for(i = 1; i <= n - k; i++)cout<< ' '; // 输出n-k个空格以保持三⾓型EnQueue(Q, 0); // ⾏界值"0"⼊队列do { // 输出第 k ⾏，计算第 k+1 ⾏DeQueue(Q, s);GetHead(Q, e);if(e) cout<< e << ' '; //若e为⾮⾏界值0，则打印输出 e 的值并加⼀空格else cout << endl; //否则回车换⾏，为下⼀⾏输出做准备EnQueue(Q, s+e);}while(e!=0);k++;}//whileDeQueue(Q, e); //⾏界值"0"出队列while (!QueueEmpty(Q)){ //单独处理第 n ⾏的值的输出DeQueue (Q, e);cout << e << ' ';}//whilecout << endl;}//yanghui。

python打印杨辉三角简单方法

Python打印杨辉三角简单方法1. 介绍杨辉三角，又称帕斯卡三角形，是数学中一个梯形状的数字阵列。

在杨辉三角中，每个数字是它上方两个数字的和。

它以排列成等腰三角形的方式排列数字。

在计算机编程中，我们可以使用Python语言来打印杨辉三角，下面将介绍一种简单的方法来实现。

2. 使用Python的循环和列表在Python中，我们可以利用循环和列表的特性来打印杨辉三角。

我们创建一个空列表来存储杨辉三角的数字。

我们使用循环来依次计算每一行的数字，并将其存储到列表中。

我们使用循环来打印出列表中的数字，从而得到杨辉三角的形状。

3. 代码示例下面是一个简单的Python代码示例，可以打印出指定行数的杨辉三角：```pythondef generate_pascals_triangle(n):triangle = []for i in range(n):row = [1] * (i + 1)for j in range(1, i):row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]triangle.append(row)return triangledef print_pascals_triangle(triangle):for row in triangle:print(" ".join(str(num) for num in row).center(len("".join(str(num) for num in triangle[-1]))))n = 10triangle = generate_pascals_triangle(n)print_pascals_triangle(triangle)```4. 代码解析在上面的代码示例中，我们首先定义了两个函数，一个用来生成杨辉三角的二维列表，另一个用来打印这个列表。

java实现杨辉三角的三种方法(含代码和解析且全面)

前言既然是实现杨辉三角，就要知道什么是杨辉三角。

如下图，就是两种杨辉三角。

（1）等边形状的杨辉三角（2）直角形状的杨辉三角在知道这两种都是杨辉三角之后，我们就来实现利用java语言打印出杨辉三角。

杨辉三角的规律：（1）第n行有n个数字.（2）每一行的开始和结尾数字都为1.用二维数组表示就是a[i][0]=1; a[i][j]=1(当i==j时)；（3）第n+1行的第i个数字等于第n行的i-1个数字加上第n行的i个数字。

用二维数组表示就是a[i+1][j]=a[i][j-1]+a[i][j];代码部分（1）创建一个长度为10，宽度为10的二维数组，但赋值和输出时只输出杨辉三角那个范围的数。

首先，我们得理解定义一个长度和高度都为10的二维数组时，他到底做了什么。

数组的图为可以看出，实际是给每个位置上都赋值为0；而我们要做的是给A部分的位置赋值并且输出，而B部分的位置不用管。

A部分与B部分的区别在于：A部分的横坐标大于等于纵坐标。

用数组中的话就是i<=j;知道要赋值的范围，那么for循环的语句就知道了啦，就为而接下来就是利用杨辉三角的特点实现赋值并输出，这里就直接看下面的完整代码吧。

第一种该方法完整代码：最后的实现效果就是下图。

（2）直接创建一个和杨辉三角形状一样的数组再赋值输出。

在前面我们使用了一个长10高10的数组，但是最后我们只用了它的A部分，思考一下，为什么我们不直接创建一个和前面那个A部分形状一样的数组呢？形状如下图：知道基本的概念之后，我们先创建该数组，首先可以确定的是这里的高度还是为10，也就是横坐标最大还是为10，但是纵坐标就是小于等于该行的横坐标。

用代码表示就是：在数组创建好之后，再就是赋值了，之前赋值用的是j<=i,但是此处数组的范围就是杨辉三角的范围，所以可以直接对数组进行内外两层循环。

用代码表示就是：而赋值的代码也是一样，不过这种方法就可以赋值完再输出，不用像第一种一样赋值时输出。

杨辉三角队列实现

网上看了许多杨辉三角队列实现的代码，结果运行时都或多或少有点小问题，为此我提供一份自己运行正确的。

程序无误，细心做一下注意，这是做成三个文件运行的第一个文件命名 stdafx.h#include<stdio.h>#include<malloc.h>#define Max 50struct queue{int *base;int front;int rear;};typedef struct queue *SqQueue;SqQueue InitQueue();//队列的初始化int EnQueue(SqQueue Q,int e);//数据进队（从队尾传值）int DeQueue(SqQueue Q);//数据出队（返回队头）void YHPrint(SqQueue Q,int n);//打印杨辉三角void jiemian();//界面函数，方便调用（个人习惯）第二个文件命名为 stdafx.c#include "stdafx.h"int GetQueueFirstData(SqQueue Q){ return Q->base[Q->front];}int isEmptyQueue(SqQueue Q){ if(Q->front=Q->rear)return 1;elsereturn 0;}SqQueue InitQueue(){ SqQueue Q;Q=(SqQueue)malloc(sizeof(struct queue));if (Q==NULL)return NULL;Q->base=(int *)malloc(Max*sizeof(int));if(Q->base==NULL)return NULL;Q->front=Q->rear=0;return Q;}int EnQueue(SqQueue Q,int e){if((Q->rear+1)%Max==Q->front)return 0;Q->base[Q->rear]=e;Q->rear=(Q->rear+1)%Max;return 1;}int DeQueue(SqQueue Q){ int e;if(Q->front==Q->rear)return 0;e=Q->base[Q->front];Q->front=(Q->front+1)%Max;return e;}void YHPrint(SqQueue Q,int n){int i,j,k,s1;int s2;for(i=1;i<=n;i++){for(k=0;k<n-i;k++)printf(" ");for(j=1,s1=0;j<i;j++){s2=DeQueue(Q);printf("%d",s1+s2);printf(" ");EnQueue(Q,s1+s2);s1=s2;}printf("1");EnQueue(Q,1);printf("\n");}}void jiemian(){int n,t;SqQueue Q;printf("杨辉三角：执行请输入：1，退出请输入：2！\n");scanf("%d",&t);do{switch(t){case 1:{Q=InitQueue();printf("请输入杨辉三角的层数：\n");scanf("%d",&n);YHPrint(Q,n);};break;case 2:printf("欢迎再次使用!");break;default:printf("输入错误：");break;}if(t==1){printf("你还想继续使用吗？继续请输入:1,退出请输入：2!\n");scanf("%d",&t);}}while(t==1);}第三个主程序命名 succeed.c就可以了，这样模块化。

数据结构实验报告四—基于队列的操作来实现杨辉三角

杨辉三角显示问题描述：编写程序，根据输入的行数，屏幕显示杨辉三角。

一、需求分析：1、行数不大于20行。

2、基于队列的操作来实现杨辉三角的不断生成过程。

（注：不要用其它的公式计算的方法或者二维数组来实现）3、基于数组实现队列的物理数据结构。

输入形式：输入一个整数n (行数不大于20)输出形式：打印出来前(n+1)行的杨辉三角数列功能实现：输出前20层的杨辉三角序列样例输入输出形式：输入：6输出：1 n=01 1 n=11 2 1 n=21 3 3 1 n=31 4 6 4 1 n=41 5 10 10 5 1 n=51 6 15 20 15 6 1 n=65、效率分析：O(n)二、概要设计：抽象数据类型void Queue::EnQueue(int item) //将元素item入列{QueueValue[++iLast]=item; } //入列int Queue::OutQueue() //第一个元素出列返回此元素{ return QueueValue[++iFront];}算法的基本思想：下面为主要实现生成杨辉三角的算法：Q.EnQueue(1); //第一行和第二行的生成Q.EnQueue(1);Q.EnQueue(1);cout<<Q.OutQueue()<<" n=0\n";for(i=3;i<=n+1;i++) //n行杨辉三角数的生成与输出 {Q.EnQueue(1);t1=Q.OutQueue();for(j=2;j<i;j++) //利用第n-1行的杨辉三角生成第n行的中间杨辉三角数{ t 2=t1;t1=Q.OutQueue(); //第n-1行第j个元素出列 Q.EnQueue(t1+t2); //第n行的第j个元素入列 cout<<t2<<" "; }Q.EnQueue(1); //第n行最后一个元素为1 cout<<t1<<" n="<<i-2<<endl; } //输出第n-1行最后1个元素Q.EnQueue(0); //以防队列为空while(--i) //输出最后一行cout<<Q.OutQueue()<<" ";cout<<" n="<<n<<endl;}程序的流程程序由三个模块组成：输入模块：输入一个整数n计算模块：栈和杨辉三角的算法输出模块：在屏幕上打印出来前(n+1)行的杨辉三角数列三、详细设计算法的具体步骤：算法思想已经在概要设计中提到了，现在通过基于队列基本操作的函数以及程序的模块化思想来实现杨辉三角的打印输出问题。