华为机试题（练习）

末蓝、 2022-05-15 15:09 307阅读 0赞

**目录**

1、选秀节目打分

2、奇偶排序

3、操作系统任务调度问题。

4. 打印数组中最大的2个数

5.回文数字判断。

6.中级题：亮着电灯的盏数

7.高级题：地铁换乘

8.判断if语句括号是否合法

9. 打印 杨辉三角形

# 1、选秀节目打分 #

分为专家评委和大众评委，score\[\] 数组里面存储每个评委打的分数，judge\_type\[\] 里存储与 score\[\] 数组对应的评委类别，judge\_type\[i\] == 1，表示专家评委，judge\_type\[i\] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分  \* 0.6 + 大众评委 \* 0.4，总分取整。如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。

函数接口   int cal\_score(int score\[\], int judge\_type\[\], int n)

package com.huawei;
    
    import java.util.Arrays;
    
    /*
     * @author yuzongtao 
     */
    public class XuanXiu {
    
    	/**
    	 * 1、选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，
    	 * judge_type[] 里存储与 score[] 数组对应的评委类别，
    	 * judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。
    	 * 打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），
    	 * 然后，总分 = 专家评委平均分  * 0.6 + 大众评委 * 0.4，总分取整。
    	 * 如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。
    	 * 函数接口  int cal_score(int score[], int judge_type[], int n) 
    	 */
    	public static void main(String[] args) {
    		int n = 10;  // n表示评委总数
    		int[] score = new int[n];
    		int[] judge_type = new int[n]; 
    		for(int i=0;i<10;i++){
    			score[i] = (int) (100*Math.random());  // score[] 数组里面存储每个评委打的分数
    			judge_type[i] = i%2 == 0 ? 1 : 2;   // judge_type[] 里存储与 score[] 数组对应的评委类别:1，表示专家评委，2，表示大众评委 
    		}
    		
    		int totalScore = cal_score(score,judge_type,n); 
    		System.out.println("score="+Arrays.toString(score));
    		System.out.println("judgeTypes="+Arrays.toString(judge_type));
    		System.out.println("totalScore="+totalScore);
    	}
    	
    	public static int cal_score(int score[], int judge_type[], int n){ 
    		int totalScore = 0; // 选手总分
    		if(null != judge_type && judge_type.length>0){ 
    			int zNum = 0;  // 专家人数
    			int dNum = 0;  // 大众人数
    			int zTotalScore = 0; // 专家总分 
    			int dTotalScore = 0; // 专家总分   
    			for(int i=0;i<judge_type.length;i++){
    				 if(judge_type[i] == 2){ 
    					 zTotalScore += score[i];
    					 zNum++;
    				 }else{
    					 dTotalScore += score[i];
    					 dNum++;
    				 }
    			 } 
    			if(dTotalScore > 0){  // 总分 = 专家评委平均分  * 0.6 + 大众评委 * 0.4，总分取整。
    				totalScore = (int) (Math.round(zTotalScore/zNum)*0.6 + Math.round(dTotalScore/dNum)*0.4);
    			}else{  //  总分 = 专家评委平均分，总分取整
    				totalScore = (int) Math.round(zTotalScore/zNum);
    			}
    			
    		}
    		return totalScore;
    	}
    
    }

输出：

score=[93, 39, 21, 42, 83, 13, 96, 34, 34, 82]
    judgeTypes=[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
    totalScore=51

# 2、奇偶排序 #

给定一个数组input\[\] ，如果数组长度n为奇数，则将数组中最大的元素放到 output\[\] 数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到 output\[\] 数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。

例如：input\[\] = \{3, 6, 1, 9, 7\}   output\[\] = \{3, 7, 9, 6, 1\};             input\[\] = \{3, 6, 1, 9, 7, 8\}    output\[\] = \{1, 6, 8, 9, 7, 3\}

函数接口   void sort(int input\[\], int n, int output\[\])

package com.huawei;
    
    import java.util.Arrays;
    
    /*
     * @author yuzongtao 
     */
    public class SortTest {
    
    	/**
    	 * 给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，
    	 * 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，
    	 * 然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
    	 * 
    	 * 例如：input[] = {3, 6, 1, 9, 7}       output[] = {3, 7, 9, 6, 1}; 
    	 *     input[] = {3, 6, 1, 9, 7, 8}    output[] = {1, 6, 8, 9, 7, 3}
    	 *     
    	 * 函数接口 void sort(int input[], int n, int output[])    
    	 */
    	public static void main(String[] args) { 
    	    int[] input = {3, 6, 1, 9, 7};
    	    int[] output = new int[input.length];
    	    sort(input,input.length,output);
    	    
    	    System.out.println(" ----------------------");
    	    
    	    int[] input2 = {3, 6, 1, 9, 7, 8};
    	    int[] output2 = new int[input2.length];
    	    sort(input2,input2.length,output2);
    	    
    	} 
    	
    	public static void sort(int input[], int n, int output[]){ 
    		boolean flag = false;  // 奇数（false）  偶数（true）
     		flag = n%2 == 1 ? false : true ;
     		Arrays.sort(input);  // input数据 正向排序
    		System.out.println("input="+Arrays.toString(input));
     		if(!flag){ // 如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置  
     			for(int i=0;i<input.length;i++){
     				if(i%2 == 0){   // 中间第奇数个数字排在右边
     					output[(n+i)/2] = input[input.length-1-i];
     				}else{  // 中间第偶数个数字排在左边
     					output[(n-i)/2-1] = input[input.length-1-i];
     				} 
     			}
     			System.out.println("output="+Arrays.toString(output));
     		}else{ // 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上
     			for(int i=0;i<input.length;i++){
     				if(i%2 == 0){   // 数组中间两个位置偏右的那个位置上
     					output[(n+i)/2] = input[input.length-1-i];
     				}else{  // 数组中间两个位置偏左的那个位置上
     					output[(n-i-1)/2] = input[input.length-1-i];
     				} 
     			}
     			System.out.println("output="+Arrays.toString(output));
     		} 
    	}
    }

输出：

input=[1, 3, 6, 7, 9]
    output=[3, 7, 9, 6, 1]
     ----------------------
    input=[1, 3, 6, 7, 8, 9]
    output=[1, 6, 8, 9, 7, 3]

# 3、操作系统任务调度问题。 #

操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task\[\]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task\[\] 中的任务按照系统任务、用户任务依次存放到 system\_task\[\] 数组和 user\_task\[\] 数组中（数组中元素的值是任务在task\[\] 数组中的下标），并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。

例如：task\[\] = \{0, 30, 155, 1, 80, 300, 170, 40, 99\}    system\_task\[\] = \{0, 3, 1, 7, -1\}    user\_task\[\] = \{4, 8, 2, 6, -1\}

函数接口    void scheduler(int task\[\], int n, int system\_task\[\], int user\_task\[\])

package com.huawei;
    
    import java.util.Arrays; 
    
    /*
     * @author yuzongtao 
     */
    public class schedulerTest {
    
    	/**
    	 * 操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。
    	 * 其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。
    	 * 现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。
    	 * 函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组
    	 * 和 user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，
    	 * 优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。
    	 * 例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}    
    	 *     system_task[] = {0, 3, 1, 7, -1}    user_task[] = {4, 8, 2, 6, -1}
    	 * 函数接口  void scheduler(int task[], int n, int system_task[], int user_task[])
    	 */
    	public static void main(String[] args) { 
    		
    		int[] task = {0, 30, 155, 1, 80, 300, 170, 40, 99};
    		int[] system_task = null;
    		int[] user_task = null;
    		scheduler(task, task.length, system_task, user_task);
    	}
    	
    	public static void scheduler(int task[], int n, int system_task[], int user_task[]){  
    		int sys_length = 0;   // 系统任务数组长度
    		int user_length = 0;  // 用户任务数组长度
    		for(int i=0;i<task.length;i++){
    			if(task[i]<50){
    				sys_length++;
    			}
    			
    			if(task[i]>=50 && task[i]<=255){ 
    				user_length++;
    			} 
    		} 
    		
    		int[] sys_value = new int[sys_length]; // 系统任务值的数组
    		int[] user_value = new int[user_length];  // 用户任务值的数组
    		system_task = new int[sys_length+1]; // 系统任务下标的数组
    		user_task = new int[user_length+1]; // 用户任务下标的数组
    		int sys_index = 0;  // 系统任务下标
    		int user_index = 0;  // 用户任务下标
    		for(int i=0;i<task.length;i++){
    			if(task[i]<50){  // 获取系统任务 值和下标的数组
    				system_task[sys_index] = i;  // 下标
    				sys_value[sys_index] = task[i];  // 值
    				sys_index++;
    			}
    			
    			if(task[i]>=50 && task[i]<=255){  // 获取用户任务 值和下标的数组
    				user_task[user_index] = i;   // 下标
    				user_value[user_index] = task[i];  // 值
    				user_index++;
    			}  
    		}
    		 
    		for(int i=0;i<sys_value.length;i++){
    			for(int j=i;j<sys_value.length;j++){
    				if(sys_value[i]>sys_value[j]){
    					// 系统任务数组值排序
    					int sys_num = sys_value[i];
    					sys_value[i] = sys_value[j];
    					sys_value[j] = sys_num;
    					
    					// 系统任务数组下标排序
    					int temp = system_task[i]; 
    					system_task[i] = system_task[j];
    					system_task[j] = temp;
    				}
    			} 
    		}
    		
    		for(int i=0;i<user_value.length;i++){
    			for(int j=i;j<user_value.length;j++){
    				if(user_value[i]>user_value[j]){
    					// 用户任务数组值排序
    					int user_num = user_value[i];
    					user_value[i] = user_value[j];
    					user_value[j] = user_num;
    					
    					// 用户任务数组下标排序
    					int temp = user_task[i]; 
    					user_task[i] = user_task[j];
    					user_task[j] = temp;
    				}
    			} 
    		}
    		system_task[system_task.length-1] = -1;
    		user_task[user_task.length-1] = -1;
    		System.out.println("task="+Arrays.toString(task));
    		System.out.println("system_task="+Arrays.toString(system_task));
    		System.out.println("user_task="+Arrays.toString(user_task));
    	} 
    }

输出：

task=[0, 30, 155, 1, 80, 300, 170, 40, 99]
    system_task=[0, 3, 1, 7, -1]
    user_task=[4, 8, 2, 6, -1]

# 4. 打印数组中最大的2个数 #

手动输入一个存储整数的数组，要求输出数组里面的2个最大值。实例： 输入：1,2,5,9,84,3,2      输出：84,9

package com.huawei;
    
    import java.util.Arrays;
    
    /*
     * @author yuzongtao 
     */
    public class FindMaxTwoNum {
    	/**
    	 * 手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
    	 * 实例： 输入：1,2,5,9,84,3,2输出：84,9
    	 */
    	public static void main(String[] args) { 
    		int[] array = {1,22,3,56,34,5,0,567};
    		Arrays.sort(array); 
    		System.out.println("最大的两个数："+array[array.length-1]+","+array[array.length-2]); 
    	}
    
    }

输出：

最大的两个数：567,56

# 5.回文数字判断。  #

有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：回文数字。编写一个函数，判断某数字是否是回文数字。

package com.huawei;
    
    /*
     * @author yuzongtao 
     */
    public class HuiWenShuTest {
    
    	/**
    	 * 回文数字判断
    	 * 有这样一类数字，他们顺着看和倒着看是相同的数，
    	 * 例如：121,656,2332等，这样的数字就称为：回文数字。
    	 * 编写一个函数，判断某数字是否是回文数字。
    	 */
    	public static void main(String[] args) {
    		int num = 123321;
    		boolean flag = isPalindrome(String.valueOf(num));
    		System.out.println("num = 123321 是否为回文数："+flag);
    
    	}
    
    	public static boolean isPalindrome(String strIn){
    		boolean flag = false;
    		String str = "";
    		char[] strIns = strIn.toCharArray();
    		for(int i=strIns.length;i>0;i--){
    			str += strIns[i-1];
    		}
    		if(strIn.equals(str)){
    			flag = true;
    		}
    		return flag;
    	}
    }

输出：

num = 123321 是否为回文数：true

# 6.**中级题：亮着电灯的盏数**   #

一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。开始，电灯全部关着。有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。注：电灯数和学生数一致。

package com.huawei;
    
    /*
     * @author yuzongtao 
     */
    public class LightTest {
    
    	/**
    	 * 亮着电灯的盏数      
    	 * 一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。
    	 * 开始，电灯全部关着。有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；
    	 * 接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；
    	 * 如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。
    	 * 注：电灯数和学生数一致。
    	 */
    	public static void main(String[] args) { 
    		int n = 100;
    		int[] lights = new int[n];
    		int[] students = new int[n];  
    		for(int i=0;i<students.length;i++){
    			for(int j=0;j<lights.length;j++){
    				if((j+1)%(i+1) == 0){ 
    					if(lights[j] == 0){
    						lights[j] = 1;  // 1 代表灯亮  
    					}else{
    						lights[j] = 0;  // 1 代表灯灭  
    					}  
    				}
    			} 
    		}  
    		
    		int num = 0;
    		for(int i=0;i<lights.length;i++){
    			if(lights[i] == 1){
    				num++;
    			} 
    		}
    		System.out.println("长廊里电灯亮着的灯数目为："+num);
    	}
    
    }

输出：

长廊里电灯亮着的灯数目为：10

# **7.高级题：地铁换乘** #

已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。  
地铁线A（环线）经过车站：

A1 A2 A3  A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18

地铁线B(直线)经过车站：  
B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15

package com.huawei;
     
    import java.util.Scanner;
    
    /*
     * @author yuzongtao 
     */
    public class StationTest {
    
    	/**
    	 * 高级题：地铁换乘
    	 * 已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。
    	 * 编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。
    	 * 地铁线A（环线）经过车站：A1 A2 A3  A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
    	 * 地铁线B(直线)经过车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
    	 */
    	public static void main(String[] args) { 
    		// 1.输入2个站点名称
    		System.out.println("请输入地铁站名称：");
    		Scanner sc = new Scanner(System.in);
    		String[] stationNames = sc.nextLine().split(",");
    		String[] stationALine = {"A1","A2","A3","A4","A5","A6","A7","A8","A9","T1","A10",
    				"A11","A12","A13","T2","A14","A15","A16","A17","A18"};
    		String[] stationBLine = {"B1","B2","B3","B4","B5","T1","B6","B7","B8","B9","B10","T2","B11","B12","B13","B14","B15"};
    		int num = 0; // 距离地铁站数目
    		// 2.计算2个站点分别在哪条地铁线上
    		String startStation = stationNames[0];
    		String endStation = stationNames[1];
    		boolean sA = isInLine(stationALine,startStation);
    		boolean sB = isInLine(stationBLine,startStation);
    		boolean eA = isInLine(stationALine,endStation);
    		boolean eB = isInLine(stationBLine,endStation);
    		 
    		// 3.计算最少经过的车站数量
    		// 3.1  如果在一条地铁站上,只需要计算一条线上的距离，不用考虑换乘，因为只允许换乘一次
    		// 3.2 如果分别在2条地铁线路上
    		if(sA && eA){  // 如果都在A地铁上
    			num = getIndex(stationALine,endStation) - getIndex(stationALine,startStation);
    		}else if(sB && eB){ // 如果都在B地铁上
    			num = getIndex(stationBLine,endStation) - getIndex(stationBLine,startStation);
    		}else{
    			int sAT1 = Math.abs(getIndex(stationALine,"T1") - getIndex(stationALine,startStation)+1);  // 起点到T1站距离
    			int sAT2 = Math.abs(getIndex(stationALine,"T2") - getIndex(stationALine,startStation)+1);  // 起点到T2站距离
    			int sBT1 = Math.abs(getIndex(stationBLine,"T1") - getIndex(stationBLine,endStation)+1);   // 终点点到T1站距离
    			int sBT2 = Math.abs(getIndex(stationBLine,"T2") - getIndex(stationBLine,endStation)+1);   // 终点点到T2站距离
    			num = sAT1 + sBT1 > sAT2 +sBT2 ? sAT2 +sBT2 : sAT1 + sBT1;  // 取最短距离
    		}
    		
            System.out.println("最少需要经过的车站数量:"+Math.abs(num+1));
    	}
    	
    	// 计算2个站点分别在哪条地铁线上
    	public static boolean isInLine(String[] stationLine,String stationName){
    		boolean flag = false;
    		for(int i=0;i<stationLine.length;i++){
    			if(stationLine[i].equals(stationName)){
    				flag = true;
    				break;
    			}
    		}
    		return flag;
    	}
    	
    	// 获取地铁站所在数组下标
    	public static int getIndex(String[] stationLine,String stationName){ 
    		int index = 0;
    		for(int i=0;i<stationLine.length;i++){
    			if(stationLine[i].equals(stationName)){
    				index = i;
    				break;
    			}
    		}
    		return index;
    	}
    
    }

输出：

请输入地铁站名称：
    A3,B9
    最少需要经过的车站数量:12

# 8.**判断if语句括号是否合法** #

编程的时候，if条件里面的“(”、“)”括号经常出现不匹配的情况导致编译不过，请编写程序检测输入一行if语句中的圆括号是否匹配正确。同时输出语句中出现的左括号和右括号数量，如if((a==1)&&(b==1))是正确的，而if((a==1))&&(b==1))是错误的。注意if语句的最外面至少有一对括号。提示：用堆栈来做。

输入：if((a==1)&&(b==1))

输出：RIGTH 3 3

输入：if((a==1))&&(b==1))

package com.huawei;
    
    import java.util.Scanner;
    import java.util.Stack;
    
    /*
     * @author yuzongtao 
     */
    public class kuoHaoMatchTest {
    
    	/**
    	 * 括号配对问题
    	 * 判断if语句括号是否合法
    	 * 编程的时候，if条件里面的“(”、“)”括号经常出现不匹配的情况导致编译不过，请编写程序检测输入一行if语句中的圆括号是否匹配正确。
    	 * 同时输出语句中出现的左括号和右括号数量，如if((a==1)&&(b==1))是正确的，而if((a==1))&&(b==1))是错误的。
    	 * 注意if语句的最外面至少有一对括号。
    	 * 提示：用堆栈来做。
    	 * 输入：if((a==1)&&(b==1))   输出：RIGHT 3 3
    	 * 输入：if((a==1))&&(b==1))  输出：WRONG 3 4
    	 */
    	public static void main(String[] args) { 
    		System.out.println("请输入测试程序段：");
    		Scanner sc = new Scanner(System.in);
    		String str = sc.nextLine();
    		String msg = isMatch(str); 
    		System.out.println(msg);
    	}
    	
    	public static String isMatch(String str){
    		String isMatch = "RIGHT"; 
    		int numLeft = 0;   // 左括号数目
    		int numRight = 0;  // 右括号数目
    		Stack<String> st = new Stack<String>();
    		if(null != str && !"".equals(str)){ 
    			
    			// 校验左右括号是否匹配 
    			for(int i=0;i<str.length();i++){
    				if('(' == str.charAt(i)){  // 遇到左括号就放入栈中
    					st.push(String.valueOf(str.charAt(i)));  
    					numLeft++;	
    				}else if(')' == str.charAt(i)){  // 遇到右括号就取出栈顶元素进行比较
    					if(!st.isEmpty() && "(".equals(st.peek())){   
    						st.pop();   // 如果栈顶元素为"(",则删除栈顶元素
    					}else{
    						isMatch = "WRONG";
    					}
    					numRight++;
    				} 
    			}
    		}
    		return isMatch+" "+numLeft+" "+numRight;
    	}
    
    }

输出：

请输入测试程序段：
    if((a==1)&&(b==1)) 
    RIGHT 3 3

请输入测试程序段：
    if((a==1))&&(b==1))
    WRONG 3 4

# 9. 打印 杨辉三角形 #

有如下规律：  
     1.左右两边都是1  
     2.有n行那么第n行就有n个数  
     3.每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和

三种实现方式，第一种是我自己写的，与第二种类似，第三种最简洁

package com.huawei;
    
    public class YangHuiSanJiao {
    
    	/**
    	 * 有如下规律：
    	 * 1.左右两边都是1
    	 * 2.有n行那么第n行就有n个数
    	 * 3.每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和
    	 */
    	public static void main(String[] args) { 
    		System.out.println("第一种实现方式："); 
    		int n=10; // 定义杨辉三角行数
    		int[][] yhArray = new int[n][n];
    		// 循环赋值得到杨辉三角的二维数组
    		for(int i=0;i<yhArray.length;i++){
    			int[] array = new int[i+1];  // 有n行那么第n行就有n个数,左右两边都是1
    			array[0] = 1;   
    			array[array.length-1] = 1;
    			for(int j=1;j<array.length-1;j++){
    				// 每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和
    				array[j] = yhArray[i-1][j-1] + yhArray[i-1][j]; 
    			} 
    			yhArray[i] = array;
    		}
    		
    		// 打印等腰杨辉三角
    		for(int i=0;i<yhArray.length;i++){
    			int[] array = yhArray[i];
    			//打印空格，第一行打印 n-1个空格，第二行n-2个空格
                for(int m = 0; m < yhArray.length - 1 - i; m++){
                    System.out.print("  ");
                }
    			for(int j=0;j<array.length;j++){
    				System.out.printf("%4d",array[j]);
    			}
    			System.out.println(""); 
    		} 
    		
    		System.out.println(""); 
    		System.out.println("==================================================");  
    		System.out.println("第二种实现方式：");   
    		
    		//定义二维数组的长度
            int length = 10;
            //声明二维数组
            int[][] arr = new int[length][];
            //遍历二维数组
            for(int i = 0; i < arr.length; i++){
                //打印空格
                for(int m = 0; m < arr.length - 1 - i; m++){
                    System.out.print("  ");
                }
                //给每个二维数据的元素赋值一维数组
                arr[i] = new int[i+1];
                //遍历一维数组
                for(int j = 0; j < arr[i].length; j++){
                    //第一个元素和最后一个元素的值都是1
                    if( j == 0 || j == arr[i].length -1 ){
                        arr[i][j] = 1;
                    }else{
                        //当前一维数组的索引n元素的值，等于前一个数组索引n-1，加上索引n的值
                        arr[i][j] = arr[i -1][j - 1] + arr[i - 1][j];
                    }
                    //格式化输出元素值
                    System.out.printf("%4d",arr[i][j]);
                }
                //换行
                System.out.println();  
            }
            
            System.out.println(""); 
    		System.out.println("==================================================");  
    		System.out.println("第三种实现方式："); 
    		
            int rows = 10; 
            for(int i =0;i<rows;i++) {
                int number = 1;
                //打印空格字符串
                System.out.format("%"+(rows-i)*2+"s","");
                for(int j=0;j<=i;j++) {
                     System.out.format("%4d",number);
                     number = number * (i - j) / (j + 1);                
                }
                System.out.println();
            }
    
    	}
    
    }

输出：

第一种实现方式：
                         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
    
    ==================================================
    第二种实现方式：
                         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
    
    ==================================================
    第三种实现方式：
                           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