JavaSE 进阶 - 第19章 数组（二）
JavaSE 进阶 - 第19章 数组（二）
- 1、数组的算法
- 2、冒泡排序
- 3、选择排序
- 4、二分法查找（折半查找）
- 5、java.util.Arrays工具类
- 传送门
1、数组的算法
1.1、常见的算法
-
排序算法：
冒泡排序算法
选择排序算法 -
查找算法：
二分法查找
以上算法在以后的java实际开发中我们不需要使用的。
因为java已经封装好了，直接调用就行。
只不过在面试的时候，可能会有机会碰上。
1.2、算法实际上在java中不需要精通，因为java中已经封装好了，要排序就调用方法就行。
例如：java中提供了一个数组工具类：java.util.Arrays
Arrays是一个工具类。
其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。
import java.util.Arrays;
//使用以下SUN公司提供的数组工具类：java.util.Arrays;
public class ArraysTest01 {
public static void main(String[] args) {
int[] arr = {112,3,4,56,67,1};
// 工具类当中的方法大部分都是静态的,直接：类名.方法名
Arrays.sort(arr);
// 遍历输出
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
/*
1
3
4
56
67
112
*/
2、冒泡排序
- 冒泡排序算法
首先从数组的最左边开始，取出第 0 号位置（左边）的数据和第 1号位置（右边）的数据，
如果左边的数据大于右边的数据，则进行交换，否而不进行交换。
接下来右移一个位置，取出第 1 个位置的数据和第 2 个位置的数据，进行比较，
如果左边的数据大于右边的数据，则进行交换，否而不进行交换。
…
沿着这个算法一直排序下去，最大的数就会冒出水面，这就是冒泡排序。
（1）每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
（2）核心：拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。
例：
参与比较的数据：9 8 10 7 6 0 11 ---共7位数字
第1次循环：
8 9 10 7 6 0 11 (第1次比较：交换) ---第 1 位和第 2 位数字比较
8 9 10 7 6 0 11 (第2次比较：不交换) ---第 2 位和第 3 位数字比较
8 9 7 10 6 0 11 (第3次比较：交换) ---第 3 位和第 4 位数字比较
8 9 7 6 10 0 11 (第4次比较：交换) ---第 4 位和第 5 位数字比较
8 9 7 6 0 10 11 (第5次比较：交换) ---第 5 位和第 6 位数字比较
8 9 7 6 0 10 11 (第6次比较：不交换) ---第 6 位和第 7 位数字比较
-------------------------最终冒出的最大数据在右边：11
参与比较的数据：8 9 7 6 0 10
第2次循环：
8 9 7 6 0 10（第1次比较：不交换）
8 7 9 6 0 10（第2次比较：交换）
8 7 6 9 0 10（第3次比较：交换）
8 7 6 0 9 10（第4次比较：交换）
8 7 6 0 9 10（第5次比较：不交换）
-------------------------最终冒出的最大数据在右边：10
参与比较的数据：8 7 6 0 9
第3次循环：
7 8 6 0 9（第1次比较：交换）
7 6 8 0 9（第2次比较：交换）
7 6 0 8 9（第3次比较：交换）
7 6 0 8 9（第4次比较：不交换）
-------------------------最终冒出的最大数据在右边：9
参与比较的数据：7 6 0 8
第4次循环：
6 7 0 8（第1次比较：交换）
6 0 7 8（第2次比较：交换）
6 0 7 8（第3次比较：不交换）
-------------------------最终冒出的最大数据在右边：8
参与比较的数据：6 0 7
第5次循环：
0 6 7（第1次比较：交换）
0 6 7（第2次比较：不交换）
-------------------------最终冒出的最大数据在右边：7
参与比较的数据：0 6
第6次循环：
0 6 （第1次比较：不交换）
-------------------------最终冒出的最大数据在右边：6
-------------------------最终冒出的最大数据在右边：0
________________________________________________________
for(int i = 6; i > 0; i--){ // 6次
//7条数据比6次
//6条数据比5次
//5条数据比4次
//4条数据比3次
//3条数据比2次
//2条数据比1次
for(int j = 0; j < i; j++){
// 交换位置。
// arr[j] 和 arr[j+1] 交换
int temp;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
public class BubbleSort {
public static void main(String[] args) {
// 这是int类型的数组对象
int[] arr = {9, 8, 10, 7, 6, 0, 11};
// 7条数据，循环6次。以下的代码可以循环6次。（冒泡排序的外层循环采用这种方式）
int count = 0;
for(int i = arr.length-1; i > 0; i--){
for(int j = 0; j < i; j++){
// 不管是否需要交换位置，总之是要比较一次的。
if(arr[j] > arr[j+1]){
// 交换位置。
// arr[j] 和 arr[j+1] 交换
int temp;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
count++;
}
}
}
System.out.println("交换位置的次数：" + count); //13
// 输出结果
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
/*
交换位置的次数：13
0
6
7
8
9
10
11
*/
3、选择排序
-
选择排序比冒泡排序的效率高。
高在交换位置的次数上。选择排序的交换位置是有意义的。 -
循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据“交换位置”。
例：
参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0）
第1次循环之后的结果是：
1 3 6 2 5
参与比较的数据：3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1）
第2次循环之后的结果是：
2 6 3 5
参与比较的数据：6 3 5 （这一堆参加比较的数据中最左边的元素下标是2）
第3次循环之后的结果是：
3 6 5
参与比较的数据：6 5 （这一堆参加比较的数据中最左边的元素下标是3）
第4次循环之后的结果是：
5 6
最终：1 2 3 5 6
注意：5条数据，循环4次。
public class SelectSort {
public static void main(String[] args) {
int[] arr = {3, 1, 6, 2, 5};
int count = 0;
int count2 = 0;
// 选择排序
// 5条数据循环4次。（外层循环4次。）
for(int i = 0; i < arr.length - 1; i++){
// i的值是0 1 2 3
// i正好是“参加比较的这堆数据中”最左边那个元素的下标。
//System.out.println(i);
// i是一个参与比较的这堆数据中的起点下标。
// 假设起点i下标位置上的元素是最小的。
int min = i;
for(int j = i+1; j < arr.length; j++){
count++;
if(arr[j] < arr[min]){
min = j; //最小值的元素下标是j
}
}
// 当i和min相等时，表示最初猜测是对的。
// 当i和min不相等时，表示最初猜测是错的，有比这个元素更小的元素，
// 需要拿着这个更小的元素和最左边的元素交换位置。
if(min != i){
// 表示存在更小的数据
// arr[min] 最小的数据
// arr[i] 最前面的数据
int temp;
temp = arr[min];
arr[min] = arr[i];
arr[i] = temp;
count2++;
}
}
// 冒泡排序和选择排序实际上比较的次数没变。
// 交换位置的次数减少了。
System.out.println("比较次数" + count); // 21
System.out.println("交换次数：" + count2); // 5
// 排序之后遍历
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
/*
比较次数10
交换次数：4
1
2
3
5
6
*/
4、二分法查找（折半查找）
-
第一：二分法查找建立在排序的基础之上。
-
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
-
第三：二分法查找原理？
10 23 56 89 100 111 222 235 500 600 arr数组 下标：0 1 2 3 4 5 6 7 8 9 目标：找出600的下标 (0 + 9) / 2 --> 4（中间元素的下标） arr[4]这个元素就是中间元素：arr[4]是 100 100 < 600 说明被查找的元素在100的右边。 那么此时开始下标变成：4 + 1 (5 + 9) / 2 --> 7（中间元素的下标） arr[7] 对应的是：235 235 < 600 说明被查找的元素在235的右边。 开始下标又进行了转变：7 + 1 (8 + 9) / 2 --> 8 arr[8] --> 500 500 < 600 开始元素的下标又发生了变化：8 + 1 (9 + 9) / 2 --> 9 arr[9]是600，正好和600相等，此时找到了。
public class ArrayUtil {
public static void main(String[] args) {
int[] arr = {100,200,230,235,600,1000,2000,9999};
// 找出arr这个数组中230所在的下标。
// 调用方法
int index = binarySearch(arr, 230);
System.out.println(index == -1 ? "该元素不存在！" : "该元素下标" + index);
}
//封装一个方法
public static int binarySearch(int[] arr, int dest) {
// 开始下标
int begin = 0;
// 结束下标
int end = arr.length - 1;
// 开始元素的下标只要在结束元素下标的左边，就有机会继续循环。
while(begin <= end) {
// 中间元素下标
int mid = (begin + end) / 2;
if (arr[mid] == dest) {
return mid;
} else if (arr[mid] < dest) {
// 目标在“中间”的右边
// 开始元素下标需要发生变化（开始元素的下标需要重新赋值）
begin = mid + 1; // 一直增
} else {
// arr[mid] > dest
// 目标在“中间”的左边
// 修改结束元素的下标
end = mid - 1; // 一直减
}
}
return -1;
}
}
/*
该元素下标2
*/
5、java.util.Arrays工具类
所有方法都是静态的，直接用类名调用
主要使用的是两个方法：
二分法查找，排序
以后要看帮助文档，不要死记硬背。
例：
import java.util.Arrays;
/**
* 好消息：
* SUN公司已经为我们程序员写好了一个数组工具类。
* java.util.Arrays;
*/
public class ArraysTest02 {
public static void main(String[] args) {
// java.util.Arrays; 工具类中有哪些方法，我们开发的时候要参考API帮助文档
// 不要死记硬背。
int[] arr = {3,6,4,5,12,1,2,32,5,5};
// 排序
Arrays.sort(arr);
// 输出
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 二分法查找（建立在排序基础之上。）
int index = Arrays.binarySearch(arr, 5);
System.out.println(index == -1 ? "该元素不存在" : "该元素下标是：" + index);
}
}
/*
1
2
3
4
5
5
5
6
12
32
该元素下标是：4
*/
传送门
上一章：JavaSE 进阶 - 第19章 数组（一）
下一章：JavaSE 进阶 - 第20章 常用类