杨辉三角形-多语言
目录
C 语言实现
方法 1: 使用二维数组
方法 2: 使用一维数组
方法 3: 递归方法
方法 4: 动态规划
Python 实现
方法 1: 使用二维列表
方法 2: 使用一维列表
方法 3: 使用递归
方法 4: 使用动态规划
Java 实现
方法 1: 使用二维数组
方法 2: 使用一维数组
方法 3: 使用递归
方法 4: 使用动态规划
Js 实现
题目：打印出杨辉三角形（要求打印出10行）。
程序分析：
结构如下所示：
| 1 2 3 4 5 |
|
C 语言实现
以下用于生成打印杨辉三角
方法 1: 使用二维数组
#include <stdio.h>
int main() {
int i, j;
int a[10][10]; // 定义一个 10x10 的二维数组
// 初始化杨辉三角的边界条件
for (i = 0; i < 10; i++) {
a[i][0] = 1; // 每行的第一个元素为 1
a[i][i] = 1; // 每行的最后一个元素为 1
}
// 填充杨辉三角的其他元素
for (i = 2; i < 10; i++) {
for (j = 1; j < i; j++) {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j]; // 计算当前元素的值
}
}
// 打印杨辉三角
for (i = 0; i < 10; i++) {
for (j = 0; j <= i; j++) {
printf("%5d", a[i][j]); // 格式化输出
}
printf("\n"); // 换行
}
return 0; // 返回 0 表示程序正常结束
}
- 数组定义：定义一个
10x10的二维数组a用于存储杨辉三角的值。 - 初始化边界：每行的第一个和最后一个元素都被初始化为
1。 - 计算内部元素：使用双重循环计算杨辉三角的内部元素，公式为
a[i][j] = a[i-1][j-1] + a[i-1][j]。 - 打印结果：最后，使用嵌套循环打印出杨辉三角的每一行。
方法 2: 使用一维数组
使用一个一维数组来存储当前行的值，并在每次迭代时更新它。
#include <stdio.h>
int main() {
int i, j;
int a[10]; // 定义一个一维数组
// 初始化杨辉三角的第一行
a[0] = 1;
printf("%5d\n", a[0]);
for (i = 1; i < 10; i++) {
// 从后往前更新数组
for (j = i; j > 0; j--) {
a[j] = a[j] + a[j - 1]; // 计算当前元素的值
}
a[0] = 1; // 每行的第一个元素为 1
// 打印当前行
for (j = 0; j <= i; j++) {
printf("%5d", a[j]); // 格式化输出
}
printf("\n"); // 换行
}
return 0; // 返回 0 表示程序正常结束
}
方法 3: 递归方法
使用递归来计算杨辉三角的值，但这种方法效率较低，适合小规模的计算。
#include <stdio.h>
int pascal(int row, int col) {
if (col == 0 || col == row) {
return 1; // 边界条件
}
return pascal(row - 1, col - 1) + pascal(row - 1, col); // 递归计算
}
int main() {
int i, j;
for (i = 0; i < 10; i++) {
for (j = 0; j <= i; j++) {
printf("%5d", pascal(i, j)); // 格式化输出
}
printf("\n"); // 换行
}
return 0; // 返回 0 表示程序正常结束
}
方法 4: 动态规划
动态规划是一种优化的递归方法，使用一个数组来存储已经计算过的值，避免重复计算。
#include <stdio.h>
int main() {
int i, j;
int a[10][10] = {0}; // 定义一个 10x10 的二维数组并初始化为 0
// 填充杨辉三角
for (i = 0; i < 10; i++) {
for (j = 0; j <= i; j++) {
if (j == 0 || j == i) {
a[i][j] = 1; // 边界条件
} else {
a[i][j] = a[i - 1][j - 1] + a[i - 1][j]; // 计算当前元素的值
}
}
}
// 打印杨辉三角
for (i = 0; i < 10; i++) {
for (j = 0; j <= i; j++) {
printf("%5d", a[i][j]); // 格式化输出
}
printf("\n"); // 换行
}
return 0; // 返回 0 表示程序正常结束
}
Python 实现
方法 1: 使用二维列表
def generate_pascals_triangle(n):
# 创建一个 n x n 的二维列表
triangle = [[0] * n for _ in range(n)]
# 初始化杨辉三角的边界条件
for i in range(n):
triangle[i][0] = 1 # 每行的第一个元素为 1
triangle[i][i] = 1 # 每行的最后一个元素为 1
# 填充杨辉三角的其他元素
for i in range(2, n):
for j in range(1, i):
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j] # 计算当前元素的值
# 打印杨辉三角
for i in range(n):
for j in range(i + 1):
print(f"{triangle[i][j]:5d}", end=' ') # 格式化输出
print() # 换行
# 生成并打印 10 行的杨辉三角
generate_pascals_triangle(10)
- 生成杨辉三角：使用一个二维列表
triangle来存储杨辉三角的值。 - 初始化边界条件：每行的第一个和最后一个元素都设置为 1。
- 填充其他元素：根据杨辉三角的性质，当前元素等于上一行的两个元素之和。
- 打印结果：格式化输出每一行的元素。
方法 2: 使用一维列表
使用一维列表来存储当前行的值，并在每次迭代时更新它。
def generate_pascals_triangle(n):
# 创建一个一维列表来存储当前行的值
current_row = [1] # 第一行
for i in range(n):
# 打印当前行
print(" ".join(f"{x:5d}" for x in current_row))
# 计算下一行
next_row = [1] # 每行的第一个元素为 1
for j in range(1, len(current_row)):
next_row.append(current_row[j - 1] + current_row[j]) # 计算当前元素的值
next_row.append(1) # 每行的最后一个元素为 1
current_row = next_row # 更新当前行
# 生成并打印 10 行的杨辉三角
generate_pascals_triangle(10)
方法 3: 使用递归
使用递归来计算杨辉三角的值，但这种方法效率较低，适合小规模的计算。
def pascal(row, col):
if col == 0 or col == row:
return 1 # 边界条件
return pascal(row - 1, col - 1) + pascal(row - 1, col) # 递归计算
def generate_pascals_triangle(n):
for i in range(n):
row = [pascal(i, j) for j in range(i + 1)] # 生成当前行
print(" ".join(f"{x:5d}" for x in row)) # 打印当前行
# 生成并打印 10 行的杨辉三角
generate_pascals_triangle(10)
方法 4: 使用动态规划
动态规划是一种优化的递归方法，使用一个数组来存储已经计算过的值，避免重复计算。
def generate_pascals_triangle(n):
# 创建一个 n x n 的二维列表
triangle = [[0] * (i + 1) for i in range(n)]
# 填充杨辉三角
for i in range(n):
triangle[i][0] = 1 # 每行的第一个元素为 1
triangle[i][i] = 1 # 每行的最后一个元素为 1
for j in range(1, i):
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j] # 计算当前元素的值
# 打印杨辉三角
for row in triangle:
print(" ".join(f"{x:5d}" for x in row if x != 0)) # 打印非零元素
# 生成并打印 10 行的杨辉三角
generate_pascals_triangle(10)
Java 实现
方法 1: 使用二维数组
public class PascalTriangle {
public static void generatePascalsTriangle(int n) {
// 创建一个 n x n 的二维数组
int[][] triangle = new int[n][n];
// 初始化杨辉三角的边界条件
for (int i = 0; i < n; i++) {
triangle[i][0] = 1; // 每行的第一个元素为 1
triangle[i][i] = 1; // 每行的最后一个元素为 1
}
// 填充杨辉三角的其他元素
for (int i = 2; i < n; i++) {
for (int j = 1; j < i; j++) {
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; // 计算当前元素的值
}
}
// 打印杨辉三角
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
System.out.printf("%5d", triangle[i][j]); // 格式化输出
}
System.out.println(); // 换行
}
}
public static void main(String[] args) {
// 生成并打印 10 行的杨辉三角
generatePascalsTriangle(10);
}
}
- 生成杨辉三角：使用一个二维数组
triangle来存储杨辉三角的值。 - 初始化边界条件：每行的第一个和最后一个元素都设置为 1。
- 填充其他元素：根据杨辉三角的性质，当前元素等于上一行的两个元素之和。
- 打印结果：使用
System.out.printf格式化输出每一行的元素。
方法 2: 使用一维数组
使用一维数组来存储当前行的值，并在每次迭代时更新它。
public class PascalTriangle {
public static void generatePascalsTriangle(int n) {
// 创建一个一维数组来存储当前行的值
int[] currentRow = new int[n];
for (int i = 0; i < n; i++) {
// 每行的第一个元素为 1
currentRow[0] = 1;
System.out.printf("%5d", currentRow[0]); // 打印第一个元素
// 计算当前行的值
for (int j = 1; j <= i; j++) {
if (j == i) {
currentRow[j] = 1; // 每行的最后一个元素为 1
} else {
currentRow[j] = currentRow[j - 1] * (i - j + 1) / j; // 使用组合数公式
}
System.out.printf("%5d", currentRow[j]); // 打印当前元素
}
System.out.println(); // 换行
}
}
public static void main(String[] args) {
// 生成并打印 10 行的杨辉三角
generatePascalsTriangle(10);
}
}
方法 3: 使用递归
使用递归来计算杨辉三角的值，但这种方法效率较低，适合小规模的计算。
public class PascalTriangle {
public static int pascal(int row, int col) {
if (col == 0 || col == row) {
return 1; // 边界条件
}
return pascal(row - 1, col - 1) + pascal(row - 1, col); // 递归计算
}
public static void generatePascalsTriangle(int n) {
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
System.out.printf("%5d", pascal(i, j)); // 打印当前元素
}
System.out.println(); // 换行
}
}
public static void main(String[] args) {
// 生成并打印 10 行的杨辉三角
generatePascalsTriangle(10);
}
}
方法 4: 使用动态规划
动态规划是一种优化的递归方法，使用一个数组来存储已经计算过的值，避免重复计算。
public class PascalTriangle {
public static void generatePascalsTriangle(int n) {
// 创建一个 n x n 的二维数组
int[][] triangle = new int[n][n];
// 填充杨辉三角
for (int i = 0; i < n; i++) {
triangle[i][0] = 1; // 每行的第一个元素为 1
triangle[i][i] = 1; // 每行的最后一个元素为 1
for (int j = 1; j < i; j++) {
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; // 计算当前元素的值
}
}
// 打印杨辉三角
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
System.out.printf("%5d", triangle[i][j]); // 打印当前元素
}
System.out.println(); // 换行
}
}
public static void main(String[] args) {
// 生成并打印 10 行的杨辉三角
generatePascalsTriangle(10);
}
}
Js 实现
function generatePascalsTriangle(n) {
// 创建一个 n x n 的二维数组
const triangle = Array.from({ length: n }, () => Array(n).fill(0));
// 初始化杨辉三角的边界条件
for (let i = 0; i < n; i++) {
triangle[i][0] = 1; // 每行的第一个元素为 1
triangle[i][i] = 1; // 每行的最后一个元素为 1
}
// 填充杨辉三角的其他元素
for (let i = 2; i < n; i++) {
for (let j = 1; j < i; j++) {
triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; // 计算当前元素的值
}
}
// 打印杨辉三角
for (let i = 0; i < n; i++) {
let row = '';
for (let j = 0; j <= i; j++) {
row += triangle[i][j].toString().padStart(5, ' '); // 格式化输出
}
console.log(row); // 打印当前行
}
}
// 生成并打印 10 行的杨辉三角
generatePascalsTriangle(10);
- 生成杨辉三角：使用一个二维数组
triangle来存储杨辉三角的值。 - 初始化边界条件：每行的第一个和最后一个元素都设置为 1。
- 填充其他元素：根据杨辉三角的性质，当前元素等于上一行的两个元素之和。
- 打印结果：使用
padStart方法格式化输出每一行的元素。