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();
