数据结构（Java）学习笔记——知识点：排序算法（二）
排序算法的学习分为三个部分：
数据结构（Java）学习笔记——知识点：排序算法（一）
数据结构（Java）学习笔记——知识点：排序算法（二）
数据结构（Java）学习笔记——知识点：排序算法（三）
十、排序算法（Sort Algorithm）
3、冒泡排序
1）基本介绍
冒泡排序（Bubble Sorting）的基本思路：假设要从小到大排序，通过对排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，如果发现逆序了，就进行交换，让较大的值的元素逐渐从前向后移动，就像气泡在水中，从下往上冒一样。
以上是传统的冒泡排序，下面是一个对传统冒泡排序的优化。
排序的过程中，每个元素都不断的靠近自己应该呆在的位置，如果连续的几个数据比较下来没有进行过交换，那就说明这段序列本身就是有序的，可以不进行交换，所以需要用一个标志 flag，来进行判断，元素是否经历过了交换。从而减少不必要的比较。
2）冒泡排序的图解
由 gif 图可以看出，其实就是每一轮循环都确定一个最大值，将最大值移动到最后位置，并且固定下来，下一次循环就不考虑它了。下一轮循环就重复这个过程，直到所有数字的位置都被固定。
那么对冒泡排序的优化呢？其实我们可以在动图中看到，其实有些时候，固定了两三个最大值后，整个序列就已经是有序的了。由于程序一次只固定一个最大值的位置，直到所有数字都固定下来，所以此时程序还是会继续执行。此时我们就可以提前结束排序。就是如果在某次排序过程中，一次都没有进行交换，就可以提前结束程序。这个就是我们后续进行优化的思路。
3）冒泡排序的代码实现
a、传统的冒泡排序
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, 20};
int temp = 0;//defined a temporary variable
int count = 0;//defined a variable to statistics sort
for(int j = arr.length; j > 1; j--){
for(int i = 0; i < j - 1; i++){
if(arr[i] > arr[i + 1]){
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
System.out.println("第" + ++count + "次排序：" + Arrays.toString(arr));
}
}
}
运行结果
第1次排序：[3, -1, 9, 10, 20]
第2次排序：[-1, 3, 9, 10, 20]
第3次排序：[-1, 3, 9, 10, 20]
第4次排序：[-1, 3, 9, 10, 20]
b、优化的冒泡排序
下面我们在用上面的思想，对冒泡排序进行一下优化。
我们怎么才能知道循环到什么时候是一次交换是没做的呢？
那么只需要定义一个标记变量 flag = false，在进行交换的时候，将 flag 的值变成 true，进行完本轮循环以后就把 flag 的值变回为 false 就行了。并且在每一次大循环的结束，对 flag 的值进行判断，如果在判断时 flag 的值还为 false，就说明本轮没有进行过交换，也就是数组中的数据已经是有序的了，此时就终止循环。
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 9, -1, 10, 20};
int temp = 0;//defined a temporary variable
int count = 0;//defined a variable to statistics sort
boolean flag = false;//defined a boolean variable to sign exchange or not
for(int j = arr.length; j > 1; j--){
for(int i = 0; i < j - 1; i++){
if(arr[i] > arr[i + 1]){
flag = true;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
if(!flag){
break;//aborted the loop
}else{
flag = false;//reset flag
}
System.out.println("第" + ++count + "次排序：" + Arrays.toString(arr));
}
}
}
运行结果
第1次排序：[3, -1, 9, 10, 20]
第2次排序：[-1, 3, 9, 10, 20]
浅测一下冒泡排序的时间
我们随机生成100000个数字，来进行冒泡排序，看能耗时多久。我们把上面的代码封装到一个方法中，然后统计一下排序前和排序后的时间，他们的差值就是排序消耗的时间了。
public class BubbleSort {
public static void main(String[] args) {
//int[] arr = {3, 9, -1, 10, 20};
int[] arr = new int[100000];
//随机生成100000个数字放到数组中
for(int i = 0; i < 100000; i++){
arr[i] = (int)(Math.random() * 100000);
}
//记录排序前的时间
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间:" + date1Str);
bubbleSort(arr);
//记录排序后的时间
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间:" + date2Str);
}
public static void bubbleSort(int[] arr){
int temp = 0;//defined a temporary variable
boolean flag = false;//defined a boolean variable to sign exchange or not
for(int j = arr.length; j > 1; j--){
for(int i = 0; i < j - 1; i++){
if(arr[i] > arr[i + 1]){
flag = true;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
if(!flag){
break;//aborted the loop
}else{
flag = false;//reset flag
}
}
}
}
运行结果
第一次：13s
排序前的时间:2023-07-17 01:11:11
排序后的时间:2023-07-17 01:11:24
第二次：12s
排序前的时间:2023-07-17 01:15:52
排序后的时间:2023-07-17 01:16:04
第三次：12s
排序前的时间:2023-07-17 01:17:04
排序后的时间:2023-07-17 01:17:16
三次的结果可以看出，我们用了大约12s或13s就可将100000个数据进行排序，数据虽然是随机的，但是时间都差不多。这个耗时我们先记下来，等到最后将所有排序的耗时进行比对，看看哪个排序算法用时最短。
4、选择排序
1）基本介绍
选择排序呢，就是第一次从 arr[0] 遍历到 arr[n-1]，找出序列中的最小值，然后将最小值与 arr[0] 进行交换。第二次就从 arr[1] 遍历到 arr[n-1]，找出最小值，将最小值与arr[1]交换，直到所有数据都有序，总共经过了 n - 1 次交换，就能得到一个从小到大的序列。
2）选择排序的图解
3）选择排序的代码实现
public class SelectSort {
public static void main(String[] args) {
int[] arr = {187,35,289,12};
int temp = 0;
int minIndex = 0;
for (int j = 0; j < arr.length; j++){
minIndex = j;
for(int i = j; i < arr.length; i++){
if(arr[j] > arr[i]){
minIndex = i;
}
}
temp = arr[j];
arr[j] = arr[minIndex];
arr[minIndex] = temp;
System.out.println(Arrays.toString(arr));
}
}
}
运行结果
[12, 35, 289, 187]
[12, 35, 289, 187]
[12, 35, 187, 289]
[12, 35, 187, 289]
浅测一下选择排序的时间
public class BubbleSort {
public static void main(String[] args) {
//int[] arr = {3, 9, -1, 10, 20};
int[] arr = new int[100000];
//随机生成100000个数字放到数组中
for(int i = 0; i < 100000; i++){
arr[i] = (int)(Math.random() * 100000);
}
//记录排序前的时间
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间:" + date1Str);
bubbleSort(arr);
//记录排序后的时间
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间:" + date2Str);
}
public static void bubbleSort(int[] arr){
int temp = 0;//defined a temporary variable
boolean flag = false;//defined a boolean variable to sign exchange or not
for(int j = arr.length; j > 1; j--){
for(int i = 0; i < j - 1; i++){
if(arr[i] > arr[i + 1]){
flag = true;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
if(!flag){
break;//aborted the loop
}else{
flag = false;//reset flag
}
}
}
}
运行结果
第一次：3s
排序前的时间:2023-07-17 14:23:21
排序后的时间:2023-07-17 14:23:24
第二次：2s
排序前的时间:2023-07-17 14:23:43
排序后的时间:2023-07-17 14:23:45
第三次：3s
排序前的时间:2023-07-17 14:23:56
排序后的时间:2023-07-17 14:23:59
三次的结果可以看出，我们用了大约3s就可将100000个数据进行排序，可以说比冒泡排序快了不止一点，由此可见好的算法的重要性。而且我们可以看出，算法的时间复杂度一样，但是他们的速度也可能是天壤之别。
5、插入排序
1）基本介绍
插入排序就是将一整个数组分成前后两部部分，将未排序的部分看作是一个无序表（数组的后部分），把已排序的部分看作是一个有序表（数组的前部分），然后将无序表的第一个元素，按照顺序插入到有序表中，以此类推，直到最后一个元素进入有序表中，就完成了排序。
2）插入排序的图解
3）插入排序的代码实现
public class InsertSort {
public static void main(String[] args) {
int[] arr = {187,35,289,12};
for(int i = 1; i < arr.length; i++){
int insertValue = arr[i];//表示要插入的数
int insertIndex = i - 1;//表示有序表的最后这个元素的下标
//insertIndex >= 0是为了保证insertValue不越界
//insertValue < arr[insertIndex]是为了保证要插入的数字小于前面的数字，这样才有插入的必要，不然可以不插入，直接排在后面就行了。
while(insertIndex >= 0 && insertValue < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}//找到了插入的位置
arr[insertIndex + 1] = insertValue;//插入数字
System.out.println(Arrays.toString(arr));
}
}
}
运行结果
[35, 187, 289, 12]
[35, 187, 289, 12]
[12, 35, 187, 289]
浅测一下插入排序的时间
public class BubbleSort {
public static void main(String[] args) {
//int[] arr = {3, 9, -1, 10, 20};
int[] arr = new int[100000];
//随机生成100000个数字放到数组中
for(int i = 0; i < 100000; i++){
arr[i] = (int)(Math.random() * 100000);
}
//记录排序前的时间
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间:" + date1Str);
bubbleSort(arr);
//记录排序后的时间
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间:" + date2Str);
}
public static void bubbleSort(int[] arr){
int temp = 0;//defined a temporary variable
boolean flag = false;//defined a boolean variable to sign exchange or not
for(int j = arr.length; j > 1; j--){
for(int i = 0; i < j - 1; i++){
if(arr[i] > arr[i + 1]){
flag = true;
temp = arr[i];
arr[i] = arr[i + 1];
arr[i + 1] = temp;
}
}
if(!flag){
break;//aborted the loop
}else{
flag = false;//reset flag
}
}
}
}
运行结果
第一次：427ms
排序前的时间:2023-07-17 15:21:21:545
排序后的时间:2023-07-17 15:21:21:972
第二次：439ms
排序前的时间:2023-07-17 15:21:54:475
排序后的时间:2023-07-17 15:21:54:914
第三次：431ms
排序前的时间:2023-07-17 15:22:02:97
排序后的时间:2023-07-17 15:22:02:528
三次的结果可以看出，我们用了大约430ms就可将100000个数据进行排序，比上面两种排序方法都更快了。
但是我们思考一下，如果说每次我们插入的数字都是最小的数字，也就是说，所有的有序部分都要后移一位，才能腾出最前面的数组位，这样就大大降低了排序的效率。所以我们就有了希尔排序。
6、希尔排序
1）基本介绍
希尔排序是希尔在1959年提出的一种排序算法。它本身也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，所以又被称为缩小增量排序。
希尔排序的思想就是将数组中的数据按照一定下标进行分组，对每组数据使用直接插入排序，随着增量的逐渐减少，每组包含的数据越来越多，直到增量减小到1的时候，整个数组被分成一组，算法终止。
上图可见，先把原始数组划分成以5为步长的5个组，8和3一组，9和5一组，1和4一组，7和6一组，2和0一组。然后将这五个组分别按照从小到大的顺序排序。第二次在以2为步长，3 1 0 9 7 一个组，5 6 8 4 2 一个组，然后再按照插入排序的方法，对数组进行排序变成【0 2 1 4 3 5 7 6 9 8】 ，然后再以1为步长，进行插入排序，最终得到【0 1 2 3 4 5 6 7 8 9】。这样排序我们可以看出，将原先两个差距很远的数，经过多次分组排序，变的很近了。可以理解成，煮土豆，一整个土豆很大块，不好煮透，但是将土豆分成好几块儿，就很快就能煮透了。
2）希尔排序的图解
3）希尔排序的代码实现
希尔排序在排序时有两种方式，第一种时交换法，第二种是移动法。
a、交换法
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8,9,1,7,2,3,5,4,6,0};
shellSort(arr);
}
//交换法
public static void shellSort(int[] arr){
int temp = 0;
int count = 0;
//每一次都除以二，这样能缩小增量
for(int gap = arr.length / 2;gap > 0; gap /= 2){
for(int i = gap; i < arr.length; i++){
for(int j = i - gap; j >= 0; j -= gap){
if(arr[j] > arr[j + gap]){
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
System.out.println("第" + count++ + "次排序：" + Arrays.toString(arr));
}
}
}
运行结果
第0次排序：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
第1次排序：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
第2次排序：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
b、移动法
移动法就是把插入排序的思想运用进来了，设置好边界值以后，就相当于以步长为准，把数据插入。
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8,9,1,7,2,3,5,4,6,0};
shellSort2(arr);
}
//移动法
public static void shellSort2(int[] arr){
int count = 0;
for(int gap = arr.length / 2;gap > 0; gap /= 2){
for(int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if(arr[j] < arr[j - gap]){
while(j - gap >= 0 && temp < arr[j - gap]){
//移动
arr[j] = arr[j - gap];
j -= gap;//往前移
}
//当退出循环后，相当于找到了插入的位置
arr[j] = temp;
}
}
System.out.println("第" + count++ + "次排序：" + Arrays.toString(arr));
}
}
}
运行结果
第0次排序：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
第1次排序：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
第2次排序：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
浅测一下希尔排序的时间
a、交换法
public class ShellSort {
public static void main(String[] args) {
/*int[] arr = {8,9,1,7,2,3,5,4,6,0};
shellSort(arr);*/
int[] arr = new int[100000];
//随机生成100000个数字放到数组中
for(int i = 0; i < 100000; i++){
arr[i] = (int)(Math.random() * 100000);
}
//记录排序前的时间
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间:" + date1Str);
shellSort(arr);
//记录排序后的时间
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间:" + date2Str);
}
//交换法
public static void shellSort(int[] arr){
int temp = 0;
int count = 0;
//每一次都除以二，这样能缩小增量
for(int gap = arr.length / 2;gap > 0; gap /= 2){
for(int i = gap; i < arr.length; i++){
for(int j = i - gap; j >= 0; j -= gap){
if(arr[j] > arr[j + gap]){
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
/*System.out.println("第" + count++ + "次排序：" + Arrays.toString(arr));*/
}
}
}
运行结果
第一次：4s
排序前的时间:2023-07-17 15:58:41
排序后的时间:2023-07-17 15:58:45
第二次：5s
排序前的时间:2023-07-17 15:59:57
排序后的时间:2023-07-17 16:00:03
第三次：6s
排序前的时间:2023-07-17 16:00:14
排序后的时间:2023-07-17 16:00:20
三次的结果可以看出，我们用了大约5s可将100000个数据进行排序，怎么这么好的算法，还速度反而慢了呢，那肯定是交换过程中出现了问题，我们来试试移动法。
b、移动法
public class ShellSort {
public static void main(String[] args) {
/*int[] arr = {8,9,1,7,2,3,5,4,6,0};
shellSort2(arr);*/
int[] arr = new int[100000];
//随机生成100000个数字放到数组中
for(int i = 0; i < 100000; i++){
arr[i] = (int)(Math.random() * 100000);
}
//记录排序前的时间
Date date1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS");
String date1Str = simpleDateFormat.format(date1);
System.out.println("排序前的时间:" + date1Str);
shellSort2(arr);
//记录排序后的时间
Date date2 = new Date();
String date2Str = simpleDateFormat.format(date2);
System.out.println("排序后的时间:" + date2Str);
}
//移动法
public static void shellSort2(int[] arr){
int count = 0;
for(int gap = arr.length / 2;gap > 0; gap /= 2){
for(int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if(arr[j] < arr[j - gap]){
while(j - gap >= 0 && temp < arr[j - gap]){
//移动
arr[j] = arr[j - gap];
j -= gap;//往前移
}
//当退出循环后，相当于找到了插入的位置
arr[j] = temp;
}
}
//System.out.println("第" + count++ + "次排序：" + Arrays.toString(arr));
}
}
}
运行结果
第一次：26ms
排序前的时间:2023-07-17 16:11:24:872
排序后的时间:2023-07-17 16:11:24:898
第二次：16ms
排序前的时间:2023-07-17 16:12:03:929
排序后的时间:2023-07-17 16:12:03:945
第三次：31ms
排序前的时间:2023-07-17 16:12:09:370
排序后的时间:2023-07-17 16:12:09:401
三次的结果可以看出，我们用了仅仅20ms左右就可将100000个数据进行排序，真是惊为天人的算法。
551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
