java基础-排序算法&&二维数组

1、冒泡排序 -- 升序

原理：
    每次比较相邻两数
    小的交换到前面
    每轮结束后最大的数交换到最后

口诀：
    冒泡排序速记口诀（升序）
        n 个数字来排队
        两两相比大靠后
        外层循环 n-1
        内层循环 n-1-i

示例：
        // 冒泡排序算法
        // 初始化一个数组
		int[] nums = {6, 3, 5, 2, 7, 4, 1, 9, 8};
		System.out.println("排序前：" + Arrays.toString(nums));
		// 外层控制轮次（n-1次）
		for (int i = 0; i < nums.length - 1; i++) {
			// 内层控制比较次数
			for (int j = 0; j < nums.length - 1 - i; j++) {
				// 判断，如是升序，大的值靠后，如果是降序，小的值靠后
				if(nums[j] < nums[j + 1]){
					// 两值互换
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		System.out.println("排序后：" + Arrays.toString(nums));

2、选择排序

/**
 * 工作原理：
 * 首先在未排序的数列中找到最大（小）元素，放到排序数列的起始位置
 * 然后再从剩余未排序的元素中继续查找最大（小）元素，放到已排序数列的末尾（按照次序），依次类推
 * @author zhukang
 *
 */
public class Xuanze {

	public static void main(String[] args) {
		// 选择排序：表现最为文档的一种排序，其排序算计简单直观
		// 初始化一个数列
		int[] nums = {66, 55, 77, 11, 33, 22, 88, 44, 99};
		System.out.println("选择排序前，初始数组：" + Arrays.toString(nums));
		
		// 使用选择排序
		for (int i = 0; i < nums.length; i++) {
			// 记录每次循环起始位置，作为查找参照初识值，如果后续有更小值，记录其下标
			int minIndex = i;
			// 从未排序的数列中查找最小或者最大值
			for (int j = i; j < nums.length; j++) {
				// 两两比较，确定最小或者最大值
				if(nums[j] > nums[minIndex]){
					// 记录已找到最小值的下标，一轮结束，就是未排序数列中的最小值下标
					minIndex = j;
				}
			}
			
			// 将最小值下标对应的值，跟外层循环的起始位置，进行数据交换
			int temp = nums[i];
			nums[i] = nums[minIndex];
			nums[minIndex] = temp;
		}
		System.out.println("选择排序后，排序数组：" + Arrays.toString(nums));
	}

}

3、Arrays工具类的用法

boolean equals(array1,array2)
    比较array1和array2两个数组是否相等
sort(array)
    对数组array的元素进行升序排列
String toString(array)
    将一个数组array转换成一个字符串
void fill(array,val)
    把数组array所有元素都赋值为val
copyOf(array,length)
    把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int binarySearch(array, val)
    查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

示例：
    	// 判断两个数组是否相等，必须长度和元素都相等，了解
		int[] scores1 = {78, 67, 89};
		int[] scores2 = {78, 67, 89, 0};
		System.out.println("数组是否相等：" + Arrays.equals(scores1, scores2));

		// 数组填充元素，了解
		int[] scores3 = new int[10];
		System.out.println("默认数组内容：" + Arrays.toString(scores3));
		Arrays.fill(scores3, 100);
		System.out.println("填充后数组内容：" + Arrays.toString(scores3));
		
		// 拷贝数组-扩容，排序，转字符串，掌握
		int[] scores4 = {11, 22, 33, 44, 55};
		// 拷贝前
		System.out.println("默认数组内容：" + Arrays.toString(scores4));
		// 扩容到10个长度
		int[] scores5 = Arrays.copyOf(scores4, 10);
		System.out.println("扩容后数组内容：" + Arrays.toString(scores5));
		// 缩减长度到3
		int[] scores6 = Arrays.copyOf(scores4, 3);
		System.out.println("缩减后数组内容：" + Arrays.toString(scores6));
		
		// 数组元素查找：前置条件-数组的元素必须是升序的，返回的是升序后的元素下标，如果不升序，返回的结果是不准确的，不可以作为查找判断条件
		int[] scores7 = {9, 6, 7, 4, 8, 3, 5, 1, 2};
		System.out.println("默认查找数组内容：" + Arrays.toString(scores7));
		// 要查找是否包含数字3
		// 必须先升序才可以
		Arrays.sort(scores7);
		System.out.println("默认查找数组升序内容：" + Arrays.toString(scores7));
		System.out.println("是否包含数字3，下标值:" + Arrays.binarySearch(scores7, 3));
		
		// 排序，默认是自然排序
		String[] names = {"jerry", "jack", "marry", "mark"};
		System.out.println("姓名数组内容：" + Arrays.toString(names));
		Arrays.sort(names);
		System.out.println("姓名数组排序后内容：" + Arrays.toString(names));

4、二维数组

语法：
    <数据类型> [ ][ ]  数组名 = new 数据类型[数组二维长度][数组一维长度];  
    或者  
    <数据类型>  数组名[ ][ ] = new 数据类型[数组二维长度][数组一维长度];  
注意：
    定义二维数组时，要定义最大维数，一维维度可以不定义，且长度不是必须一致的
    二维数组实际上是一个以一维数组做为元素的一维数组
    通过二维数组名获取长度，返回的是二维的长度，即有几个一维数组

示例：
    int [ ][ ] scores = new int[5][]; -- 正确
    int [ ][ ] scores = new int[][]; -- 错误

定义并赋值：
    int[][] scores = new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
    或者
    int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

遍历二维数组：
		// 外层是二维长度
		for (int i = 0; i < scores.length; i++) {
			// 内层是一维数组的真是长度
			for (int j = 0; j < scores[i].length; j++) {
				System.out.print(scores[i][j] + " ");
			}
			System.out.println();
		}
示例：
        // 按规律输出数字列表
        /**
		 * 特殊数列
		 * 1
		 * 2 6
		 * 3 7 10
		 * 4 8 11 13
		 * 5 9 12 14 15
		 */
		Scanner input = new Scanner(System.in);
		System.out.print("请输入数列的行数：");
		int line = input.nextInt();
		// 定义二维数组存放数据
		int[][] nos = new int[line][line];
		
		// 定义初始值为1，进行累加
		int num = 1;
		
		// 给二维数组赋值
		for (int i = 0; i < nos.length; i++) {
			for (int j = i; j < nos[i].length; j++) {
				nos[j][i] = num++;
			}
		}
		
		// 遍历二维数组，排除默认值0
		for (int i = 0; i < nos.length; i++) {
			for (int j = 0; j < nos[i].length; j++) {
				// 如果是0，不输出
				if(nos[i][j] == 0){
					continue;
				}
				System.out.print(nos[i][j] + " ");
			}
			System.out.println();
		}
		input.close();