第一种
package mianxiangduixiang;
public class Demo01 {
public static void main(String[] args) {
/**
* 杨辉三角
* 1
*2 1 1 arr[1][0] arr[1][1]
*3 1 2 1 arr[2][0] arr[2][1] arr[2][1]
*4 1 3 3 1
*5 1 4 6 4 1
*6 1 5 10 10 5 1
*
*每一行相当于二维数组的子项,但是每一个子项的长度第不一样的
*1.每一项的索引和长度的关系 +1
*2.每一个子项的开头和结尾都是1 arr[i][0] = 1 arr[i][arr[i].lengh-1]=1
*3.去除开头和结尾中间的每一行都是子项的
*arr[index][i] = arr[index-1][i] +arr[index-1][i-1]
*index[][] arr = new int[6][]
*/
int[][] arr= new int[10][];
for (int i = 0; i < arr.length; i++) {
//1.遍历初始化每一项的长度
arr[i] = new int[i+1];
//2.填写 遍历每一个子项
for (int j = 0; j < arr[i].length; j++) {
//3.开头和结尾都是1
if(j==0 || j==arr[i].length-1){
arr[i][j]= 1;
}else {
arr[i][j] = arr[i-1][j] +arr[i-1][j-1];
}
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
=============================================
第二种
package mianxiangduixiang;
public class Demo03 {
public static void main(String args[])
{
int x=10;//输入几层是几层
int num[][] = new int[x][x];//这个数组有几层
for(int m=0;m<x;m++)//主要是对数组进行赋值
{
for(int n=0;n<=m;n++)//每一层的个数都是小于等于层数的，m代表层数，n代表着第几个数
{
if(n==0||m==n)//每一层的开头都是1，m==n的时候也是1,必须要这个，凡事都得有个开头
{
num[m][n]=1;
}
else
num[m][n]=num[m-1][n-1]+num[m-1][n];//这个就是递推的方法了，例如3=1+2，3的坐标就是3[3,1]=1[2,0]+2[2,1];
}
}
for(int i=0;i<x;i++)//主要是输出数组
{
for(int l=i;l<x;l++)//这个主要是打空格，好看一点，去掉就是直角三角形了
{
System.out.print(" ");
}
for(int j=x-i;j<=x;j++)//这个就是打印数组了，每层循环几次就几个
{
System.out.print(num[i][x-j]+" ");//不懂的可以把x替换成10，更加清楚点
}
System.out.println();//每层换行
}
}
}
======================================================================
第三种
package mianxiangduixiang;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[][] sum = new int[n][n];
for(int i = 0;i < n;i ++){
sum[i][0] = 1;
sum[i][i] = 1;
for(int j = 1;j < i;j ++){
sum[i][j] = sum[i-1][j-1] + sum[i-1][j];
}
}
for(int i = 0;i < n;i ++){
for(int j = 0;j <= i;j ++){
System.out.print(sum[i][j] + " ");
}
System.out.println();
}
}
}
//===============================================
第四种
package mianxiangduixiang;
//【程序33】YangHui.java 题目：打印出杨辉三角形（要求打印出10行如下图） 1.程序分析：
// 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1
public class Yanghui1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
YangHui yh=new YangHui();
yh.print();
}
}
class YangHui{
int a[][];
YangHui(){
a=new int[10][10];
a[0][0]=a[1][0]=a[1][1]=1;
}
public void print(){
for(int k=1;k<10;k++)
a[k][k]=1;
for(int f=0;f<10;f++)
a[f][0]=1;
for(int i=2;i<10;i++){
for(int j=1;j<i;j++){
a[i][j]=a[i-1][j-1]+a[i-1][j];
}
}
for(int i=0;i<10;i++){
for(int j=0;j<=i;j++)
System.out.print(a[i][j]+" ");
System.out.println();
}
}
}
===================================
第五种
package mianxiangduixiang;
/**
*
* @author zjluoc
*
*/
public class YangHuiTriangle {
private static String singleSpaceString = " ";// 用于补齐数据空格的单个字符串
public static void main(String args[]) {
printYangHuiTriangle(20);
}
/**
* 打印对应层数lines的杨辉三角形
*
* @param lines
* 层数
*/
public static void printYangHuiTriangle(int lines) {
// 首先定义一个二维数组用于存储每一层对应行列的数值
long yh[][] = new long[lines][lines];
// 接着定义每一层首位和末尾均为1，此处for循环给边界赋值“1”。
for (int i = 0; i < lines; i++) {
yh[i][0] = yh[i][i] = 1;
}
// 接着计算从第三层开始那些由肩部两端相加的和
for (int i = 2; i < lines; i++) {// 控制层从第三层到最后一层，2~lines-1
for (int j = 1; j < i; j++) {// 每一层除去首尾2个数，只有（i+1）-2个数需要计算，说明j最大值为i-1
// 计算肩部数字之和
yh[i][j] = yh[i - 1][j - 1] + yh[i - 1][j];
}
}
/*
* 进行到这里已经计算好了每层的数字，现在下面开始对其进行塑造三角形形状
*/
// 获得调整后的相同数据长度的二维字符数据数组
String[][] adjustedNumberStringArray = adjustDigitalLength(yh,
singleSpaceString);
// 获取单个数据字符串长度作为单个需要打印补齐的空格长度
int time = adjustedNumberStringArray[0][0].length()
- singleSpaceString.length();
if (time > 0) {
StringBuilder sb = new StringBuilder(singleSpaceString);
for (int i = 0; i < time; i++) {
sb.append(singleSpaceString);
}
singleSpaceString = sb.toString();
}
for (int i = 0; i < adjustedNumberStringArray.length; i++) {
// 打印每行数据首个数据补齐字符singleSpaceString
for (int k = 0; k < adjustedNumberStringArray.length - i - 1; k++) {
System.out.print(singleSpaceString);
}
for (int j = 0; j <= i; j++) {
// 打印每个字符数据+singleSpaceString,最后一个数据不加
if (j != i) {
System.out.print(adjustedNumberStringArray[i][j]
+ singleSpaceString);
} else {
// 每层结束后换行
System.out.println(adjustedNumberStringArray[i][j]);
}
}
}
}
/**
* 找出原始数据中最大字节长度，再对原来每个数据动态调整数据字节长度使其保持一致
*
* @param yh
* 杨辉三角原始数据二维数组
* @return String[][] 调整长度后的数据字符串二维数组
*/
private static String[][] adjustDigitalLength(long[][] yh,
String singleSpaceString) {
// 找出最长的数据字符串长度
int maxNumberStringLength = 0;
// 存储长度调整后的数据字符串二维数组
String[][] numberStringArray = new String[yh.length][yh.length];
for (int i = 0; i < yh.length; i++) {
for (int j = 0; j <= i; j++) {
// 每层数字转换为字符串后计算长度,取得最大的数据字符串长度
numberStringArray[i][j] = String.valueOf(yh[i][j]);
if (String.valueOf(yh[i][j]).length() > maxNumberStringLength) {
maxNumberStringLength = String.valueOf(yh[i][j]).length();
}
}
}
// 用空格补齐数据字符长度,让每一个数据字符串长度都达到最大数据字符串长度
for (int i = 0; i < numberStringArray.length; i++) {
for (int j = 0; j <= i; j++) {
// 计算每个数据字符串相差几个空格
int spaceLength = maxNumberStringLength
- numberStringArray[i][j].length();
// 用空格补齐至最大长度
if (spaceLength > 0) {
StringBuilder sb = new StringBuilder(
numberStringArray[i][j]);
for (int k = 0; k < spaceLength; k++) {
sb.append(singleSpaceString);
}
numberStringArray[i][j] = sb.toString();
}
}
}
return numberStringArray;
}
}