数组、排序和查找(二)

1、排序的介绍

排序是将多个数据，依指定的顺序进行排列的过程。
排序的分类:

1.1 内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法);

1.2 外部排序法:

数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)。

2、冒泡排序法

冒泡排序(Bubble Sorting)的基本思想是:
通过对待排序序列从后向前(从下标较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

下面我们举一个具体的案例来说明冒泡法。我们将五个无序:24,69,80,57,13 使用冒泡排序法将其排成一个从小到大的有序数列。

public class BubbleSort {
	//编写一个 main 方法
	public static void main(String[] args) {
		//老韩 化繁为简，先死后活
		int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110}; 
		int temp = 0; //用于辅助交换的变量
		//将多轮排序使用外层循环包括起来即可
		for( int i = 0; i < arr.length - 1; i++) {//外层循环是 4 次
			for( int j = 0; j < arr.length - 1 - i; j++) {
				//4次比较-3次-2次-1次 
				//如果前面的数>后面的数，就交换
				if(arr[j] > arr[j + 1]) {
					temp = arr[j]; 
					arr[j] = arr[j+1]; 
					arr[j+1] = temp;
				} 
			}
			System.out.println("\n==第"+(i+1)+"轮=="); 
			for(int j = 0; j < arr.length; j++) {
				System.out.print(arr[j] + "\t");
			} 
		}
	}
}

3、查找

3.1 介绍:

在 java 中，我们常用的查找有两种:

1. 顺序查找
2. 二分查找

3.1.1顺序查找

int index = -1;
for(int i = 0; i < names.length; i++) {
	//比较 字符串比较 equals, 如果要找到名字就是当前元素 
	if(findName.equals(names[i])) {
		System.out.println("恭喜你找到 " + findName); 	
		System.out.println("下标为= " + i);
		//把 i 保存到 index
		index = i;
		break;//退出 
	}
}

if(index == -1) { //没有找到
	System.out.println("sorry ,没有找到 " + findName);
}

3.1.1二分查找（有序的前提下）

使用条件：
查找序列是顺序结构，有序。

二分查找思想：

1. 将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；
2. 否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表
3. 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

		int low = 0;
		int high = arr.length - 1;
		int middle = 0;		
		
		if(key < arr[low] || key > arr[high] || low > high){
			return -1;				
		}
		
		while(low <= high){
			middle = (low + high) / 2;
			if(arr[middle] > key){
				//比关键字大则关键字在左区域
				high = middle - 1;
			}else if(arr[middle] < key){
				//比关键字小则关键字在右区域
				low = middle + 1;
			}else{
				return middle;
			}
		}
		
		return -1;		//最后仍然没有找到，则返回-1

4、多维数组-二维数组

1. 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值还需要再次遍历
2. 如果我们要访问第 (i+1)个一维数组的第 j+1 个值 arr[i][j];

4.2 使用方式 1: 动态初始化

1. 语法: 类型[ ][ ] 数组名=new 类型[大小][大小]
2. 比如:int a[ ][ ]=new int[2][3]

4.3 使用方式 2: 动态初始化

先声明:类型 数组名[ ][ ];
再定义(开辟空间) 数组名 = new 类型[大小][大小]
赋值(有默认值，比如 int 类型的就是 0)

4.4 使用方式 3: 动态初始化-列数不确定

4.5 使用方式 4: 静态初始化

定义 类型 数组名[][] = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}}
使用即可 [ 固定方式访问 ]
比如:

int[ ][ ] arr = {{1,1,1}, {8,8,9}, {100}};

5、二维数组的应用案例

使用二维数组打印一个 10 行杨辉三角

public static void main(String[] args) {
	/*
		使用二维数组打印一个 10 行杨辉三角 1
		规律
		1.第一行有 1 个元素, 第 n 行有 n 个元素
		2. 每一行的第一个元素和最后一个元素都是 1
		3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
		arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律
	*/
	int[][] yangHui = new int[12][];
	for(int i = 0; i < yangHui.length; i++) {
		//遍历 yangHui 的每个元素
		//给每个一维数组(行) 开空间 
		yangHui[i] = new int[i+1]; 
		//给每个一维数组(行) 赋值
		for(int j = 0; j < yangHui[i].length; j++){
			//每一行的第一个元素和最后一个元素都是 1 
			if(j == 0 || j == yangHui[i].length - 1) {
				yangHui[i][j] = 1; } 
			else {//中间的元素
				yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1]; 
			}
		} 
	}
	//输出杨辉三角
	for(int i = 0; i < yangHui.length; i++) {
		for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行 
			System.out.print(yangHui[i][j] + "\t");
		}
		System.out.println();//换行. 
	}
}

6、二维数组使用细节和注意事项

1. 一维数组的声明方式有:
   int[ ] x 或者 int x[ ]
2. 二维数组的声明方式有:
   int[ ][ ] y 或者 int[ ] y[ ] 或者 int y[ ][ ]
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。
   比如: map[][] 是 一个二维数组
   int map [][] = {{1,2},{3,4,5}}
   由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组.

本博客引用韩顺平老师java课程