分别用二维数组、一维数组、递归等三种方法实现杨辉三角；
杨辉三角：首尾都为1，中间数值等于其肩上两个数值之和，形如下面：

                                      1     
                                   1     1     
                                1     2     1     
                             1     3     3     1 

意义：杨辉三角是二项式（a+b）^n展开式的系数表，比如n=2时
(a+b)^2 = a^2 + 2ab + b^2
系数对应为 1 2 1，正好是杨辉三角的第三行

如下是完整的Java代码：

package algorithm;

public class YangHui {

    /** * @param args */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        YangHui yh = new YangHui();
        yh.pattern(4);//模型化输出
        yh.dyadic(17);//二维数组实现
        yh.linear(14);//一维数组实现
        yh.recurrencePrint(14);//递归实现
    }

    // 模型化输出
    public void pattern(int n) {
        for (int i = 1; i <= n; i++) {// i控制行
            for (int k = 1; k <= n - i; k++) {// k控制列空格
                System.out.print(" ");
            }
            for (int j = 1; j <= 2 * i - 1; j++) {// j控制列*
                System.out.print("*");
            }
            System.out.println();// 换行
        }
    }

    // 二维数组实现
    public void dyadic(int n) {
        int[][] a = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int k = 1; k < n - i; k++) {
                System.out.printf("%3s", " ");// 控制左边空格,以输出字符串的一半字符量为单位
            }
            for (int j = 0; j <= i; j++) {
                if (j == 0 || j == i) {
                    a[i][j] = 1;// 首尾都是1
                } else {
                    a[i][j] = a[i - 1][j - 1] + a[i - 1][j];// 中间值等于其肩上两个值之和
                }
                System.out.printf("%-6s", a[i][j]);// 左对齐，每个输出字符占6个字节，可保证5位数之内保持齐整
            }
            System.out.println();
        }
    }

    // 一维数组实现
    public void linear(int n) {
        int[] a = new int[n];
        // 用变量i来控制行，用一维数组a[i]来记录每一行的数值
        for (int i = 0; i < n; i++) {
            a[i] = 1;// 由于i一直在++，因此a[0]=1将永远都不会变了，同时a[i]，即每一行的最后一个数值也将永远为1
            for (int k = 1; k < n - i; k++) {
                System.out.printf("%3s", " ");// 输出左边空格
            }
            for (int j = i - 1; j > 0; j--) {
                /* * 由于杨辉三角成金字塔形，后一行比前一行多出首尾两个数字，而当变量i每次变化的时候， * 第一个数字永远定格为1，不会再更新，但是每一行的最后一个值每次都会随着i的变化被赋值为1， * 虽然i已经+1了，但是a[i]中首尾之间的数值依然没有变化，还是上一行的值，这就是本算法的核心点； * 等号右边的a[j-1]和a[j]是上一行，即i-1时的值，等号左边的a[j]才是当前i的值； */
                a[j] = a[j - 1] + a[j];
            }
            for (int j = 0; j <= i; j++) {
                System.out.printf("%-6s", a[j]);// 倒着计算，顺着输出，左对齐
            }
            System.out.println();
        }
    }

    // 递归实现
    public int recurrence(int i, int j) {
        if (i == j || j == 0) {
            return 1;// j=0代表每行的第一列，i==j代表每行的最后一列
        } else {
            return recurrence(i - 1, j - 1) + recurrence(i - 1, j);// 从源头寻找递归加和
        }
    }

    // 递归打印
    public void recurrencePrint(int n) {
        for (int i = 0; i < n; i++) {
            for (int k = 1; k < n - i; k++) {
                System.out.printf("%3s", "");
            }
            for (int j = 0; j <= i; j++) {
                System.out.printf("%-6s", recurrence(i, j));
            }
            System.out.println();
        }
    }
}

期待你更高效的算法！