Java程序设计语言D实验二——Java的数组实验

一、实验内容描述（问题域描述）

【实验题目】Java的数组
【实验目的】熟练掌握java的一维、多维数组的使用。
【实验内容】
（1）编写一个程序，生成一个10*10的二维随机整数数组，并将该数组的每行最大值保存于一个一维数组中，将每列平均值保存于另外一个一维数组中并分别输出。
（2）找出一个二维数组的鞍点，即该位置上的元素在该行上最大，在该列上最小（注：一个二维数组也可能没有这样的鞍点）。
（3）编程输出杨辉三角的前10行。

二、实验基本原理与设计（包括实验方案设计，实验手段的确定，试验步骤等，用硬件逻辑或者算法描述）

使用随机数生成1000以内的随机数：
Random r = new Random();
for(int i = 0;i < arr2D[0].length;i++){
for(int j = 0;j < arr2D.length ;j++){
arr2D[i][j] = r.nextInt(1000);
System.out.print( arr2D[i][j]+" ");
}
System.out.println();
}

使用快速排序将每行的元素从小到大排列，然后每行的第九个元素就是每行的最大值。
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。 [2]
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

核心代码为：
public static int getIndex(int arr[],int low ,int high){
int key = arr[low];
while(low < high){
while(low<high && arr[high]>= key){
high–;
}
arr[low] = arr[high];
while(low < high && arr[low] <=key){
low++;
}
arr[high] = arr[low];
}
arr[low] = key;
return low;
}

在获取二维数组的鞍点的时候，逐一遍历每个二维数组元素 arr2D[i][j],然后找到第i行的最大值max，第j列的最小值min，若是arr2D[i][j]=max&&arr2D[i][j]=min,则说明该元素arr2D[i][j]是数组的鞍点，否则就不是。

第二部分：实验调试与结果分析（可加页）
一、调试过程（包括调试方法描述、实验数据记录，实验现象记录，实验过程发现的问题等）

杨辉三角的规律：

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

具体代码：
int[][] arr=new int[10][];
for(int i=0;i<arr.length;i++) {
arr[i]=new int[i+1];
}
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr[i].length;j++) {
if(j0 || ij) {
arr[i][j]=1;
}else {
arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
}
}
}
经过格式化输出后达到该效果：

三、实验结果及分析（包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等）

对于二维数组而言，我们在进行获取每行的最大值的时候，我们可以首先对这个二维数组的每行进行快速排序人得到每行从小到大一次递增，在进行查找鞍点的时候就容易多了。由于是使用的时候随机数产生一组1010的二维数组，所以每次产生的结果都是不一样，这也就导致了每个二维数组出现鞍点的概率很小，当然，如果是55的维数组的话，那么这个出现鞍点概率就大很多。因此可以知道，二维数组的长度是可以影响鞍点出现的概率的，二维数组的长度越长，那么它出现鞍点的概率就越小。

四、实验小结、建议及体会

通过此次实验，对二维数组的使用以及杨辉三角的原理有了更深的理解。同时，私用数据结构中的快速排序，强化了专业课数据结构的知识。

五、源代码

package two;

import java.util.Random;

/**
 * @author 陌意随影
 TODO :生成一个10*10的二维随机整数数组，
 并将该数组的每行最大值保存于一个一维数组中，
 将每列平均值保存于另外一个一维数组中并分别输出。
 *2019年12月16日  上午10:57:08
 */
public class Array2DDemo {

	public static void main(String[] args) {
		//十乘十二维数组
     showArray2D();
      //寻找鞍点
     while(true){
    	boolean fla = findAndian();
    	 if(!fla){
    		 break;
    	 }
     }
     //杨辉三角
     yanghuisuaojiao();
	}
	private static boolean findAndian() {
		//获取随机的二维数组
		int[][] arr2D = new int[10][10];
		 Random r = new Random();
		  for(int i = 0;i < arr2D[0].length;i++){
			  for(int j = 0;j < arr2D.length ;j++){
				  arr2D[i][j] = r.nextInt(1000);
				  System.out.print( arr2D[i][j]+" ");
			  }
			  System.out.println();
		  }
		  //装取鞍点的一维数组，可能是未必有10个
		int[] values = new int[arr2D.length];
		for(int i = 0 ;i < arr2D.length;i++){
			for(int j = 0;j < arr2D[i].length;j++){
				//获得每行的最大值
				int maxValueOf =  maxValueOfRow( arr2D[i]);
				//获得每列的最小值
				int minValueOf = minValueOfClomn(arr2D, j);
				int value =  arr2D[i][j];
				if(maxValueOf ==value&& minValueOf == value){
					values[i] = value;
				}
				
			}
		}
		    System.out.println("鞍点：");
		    boolean fla = false;
			  for(int i = 0;i < values.length;i ++){
				  System.out.print(values[i]+ " ");
				  if(values[i]!= 0){
					  fla = true;
				  }
			  }
			  System.out.println();
		  if(fla ){
			  System.out.println("有鞍点！");
		  }else{
			  System.out.println("无鞍点！");
		  }
		  return fla;
	}
	/**
	 * @return 返回每行中的最小值
	 */
	public static int maxValueOfRow(int [] arr){
		int[] newArr  = new int[arr.length];
		for(int i =0 ; i< newArr.length;i++){
			newArr[i] = arr[i];
		}
		//从小到大排序
		QuitSort(newArr, 0,newArr.length-1);
		//返回最大值
		return newArr[newArr.length-1];
		
	}
	/**
	 * @param arr2D
	 * @param index
	 * @return 返回该index列的最小值
	 */
	public static int minValueOfClomn(int [][] arr2D,int index){
		int min =arr2D[0][index];
		for(int i = 1;i < arr2D.length;i++){
			if(min > arr2D[i][index]){
				min =arr2D[i][index];
			}
		}
		return min;
		
	}
	
	/**
	 * 打印杨辉三角
	 */
	public static void yanghuisuaojiao() {
		int[][] arr=new int[10][];
		for(int i=0;i<arr.length;i++) {
			arr[i]=new int[i+1];
		}
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr[i].length;j++) {
				if(j==0 || i==j) {
					arr[i][j]=1;
				}else {
					arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
				}
			}
		}
		for(int i=0;i<arr.length;i++) {
			int num=(arr.length-i)/2;
			for(int k=0;k<=num;k++) {
				System.out.print("\t");
			}
			for(int j=0;j<arr[i].length;j++) {
				System.out.print(arr[i][j]+"\t");
			}
			System.out.println();
		}
	}
	private static void showArray2D() {
		int[][] arr2D = new int[10][10];
		 Random r = new Random();
		  for(int i = 0;i < arr2D[0].length;i++){
			  for(int j = 0;j < arr2D.length ;j++){
				  arr2D[i][j] = r.nextInt(100);
			  }
		  }
		  //对二维数组的每行进行快速排序 
		  for(int i = 0;i < 10;i ++){
			  QuitSort(arr2D[i], 0, arr2D.length - 1);
		  }
		  int[] maxRowValues = new int[10];
		  //获取每行的最大值
		  for(int i = 0;i < 10;i ++){
			  maxRowValues[i] = arr2D[i][9];
		  }
		 int[] arrRowAvg = new int[10];
		  //获取每行的平均值
		  for(int i = 0;i < arr2D.length;i++){
			  int sum = 0;
			  for(int j = 0;j < arr2D[i].length;j++){
				  sum += arr2D[i][j];
			  }
			  arrRowAvg[i] = sum/arr2D[i].length;
		  }
		  System.out.println("每行的最大值");
		  for(int i  = 0; i < maxRowValues.length;i++){
			  System.out.print(maxRowValues[i]+ " ");
		  }
		  System.out.println();
		  System.out.println("每行的平均值");
		  
		  for(int i = 0;i < arrRowAvg.length;i ++){
		        System.out.print( arrRowAvg[i] + " ");    		  
			  }
	}
/**
 * 对一维数组进行快速排序
 * @param arr
 */
public static void QuitSort(int arr[],int low ,int high){
	if(low< high){
		int index = getIndex(arr, low, high);
		QuitSort(arr, 0,index -1);
		QuitSort(arr, index+1, high);
	}
}
/**
 * 获取快速排序的分界索引
 * @param arr 
 * @param low
 * @param high
 */
public static int getIndex(int arr[],int low ,int high){
	int key = arr[low];
	while(low < high){
		while(low<high && arr[high]>= key){
			high--;
		}
		arr[low] = arr[high];
		while(low < high && arr[low] <=key){
			low++;
		}
		arr[high] = arr[low];
	}
	arr[low] = key;
   return low;	
}


}

六、本博客已经同步到个人博客，如有需要请自行移步：http://moyisuiying.com/index.php/experiment/javaexperiment/316.html