冒泡排序
依次比较相邻的两个数,将小数放在前面,大数放在后面。即首先比较第1个和第2个数,将小数放前,大数放后。然后比较第2个数和第3个数,将小数放前,大数放后,如此继续,直至比较最后两个数,将小数放前,大数放后。重复以上过程,仍从第一对数开始比较(因为可能由于第2个数和第3个数的交换,使得第1个数不再大于第2个数),将小数放前,大数放后,一直比较到最小数前的一对相邻数,将小数放前,大数放后,第二趟结束,在倒数第二个数中得到一个新的最小数。如此下去,直至最终完成排序。
由于在排序过程中总是小数往前放,大数往后放,相当于气泡往上升,所以称作冒泡排序。
冒泡排序动态图:
冒泡排序核心思路代码:
public static void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int minVal = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = minVal;
}
}
}
}
全部代码:
package com.ggsddu.domain.sort;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class BubbleSort {
public static void main(String[] args) {
System.out.print("输入数组长度:");
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int[] arr = new int[n];
Random random = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = random.nextInt(100);
}
scanner.close();
System.out.println("排序前:" + Arrays.toString(arr));
System.out.println("--------------------- 排序结束 ---------------------");
sort(arr);
System.out.println("--------------------- 排序结束 ---------------------");
System.out.println("排序后:" + Arrays.toString(arr));
}
public static void sort(int[] arr) {
/**
* 假设数组有10个元素,外层循环9次,每轮排序将此轮参与比较元素的最大值“冒泡”出去
* ----- 排序开始
* 第一轮排序:从10个元素中比较出最大值,将最大值“冒泡”到数组arr[9]的位置
* 第二轮排序:从9个元素中(已“冒泡”元素不参与后续排序)比较出最大值,“冒泡”到数组arr[8]的位置
* 第三轮排序:从8个元素中比较出最大值,“冒泡”到最后数组arr[7]的位置
* ...
* 第八轮排序:从3个元素中比较出最大值,“冒泡”到最后数组arr[2]的位置
* 第九轮排序:从2个元素中比较最大值,“冒泡”到数组arr[1]的位置,则arr[0]最小不动,排在arr[0]
* ----- 排序结束
*/
for (int i = 0; i < arr.length - 1; i++) {
/**
* 内层循环控制当前轮排序的参与比较的元素(已“冒泡”元素不再参与后续排序)
* 第一轮排序,参与排序的元素个数为arr.length - 1 - 0
* 第二轮排序,参与排序的元素个数为arr.length - 1 - 1
* 第三轮排序,参与排序的元素个数为arr.length - 1 - 2
* ...
* 第i轮排序,参与排序的元素个数为arr.length - 1 - i
*/
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int minVal = arr[j + 1];
arr[j + 1] = arr[j];
arr[j] = minVal;
}
}
System.out.println("第 " + (i + 1) + " 次排序:" + Arrays.toString(arr));
}
}
}
控制台打印结果:
输入数组长度:10
排序前:[64, 89, 36, 57, 82, 70, 40, 61, 81, 15]
--------------------- 排序开始 ---------------------
第 1 次排序:[64, 36, 57, 82, 70, 40, 61, 81, 15, 89]
第 2 次排序:[36, 57, 64, 70, 40, 61, 81, 15, 82, 89]
第 3 次排序:[36, 57, 64, 40, 61, 70, 15, 81, 82, 89]
第 4 次排序:[36, 57, 40, 61, 64, 15, 70, 81, 82, 89]
第 5 次排序:[36, 40, 57, 61, 15, 64, 70, 81, 82, 89]
第 6 次排序:[36, 40, 57, 15, 61, 64, 70, 81, 82, 89]
第 7 次排序:[36, 40, 15, 57, 61, 64, 70, 81, 82, 89]
第 8 次排序:[36, 15, 40, 57, 61, 64, 70, 81, 82, 89]
第 9 次排序:[15, 36, 40, 57, 61, 64, 70, 81, 82, 89]
--------------------- 排序结束 ---------------------
排序后:[15, 36, 40, 57, 61, 64, 70, 81, 82, 89]
Process finished with exit code 0
快速排序
快速排序由
C. A. R. Hoare
在1962年提出。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
借一张大佬的图,传送门:http://blog.csdn.net/it_zjyang/article/details/53406764
初始数组:[3, 7, 2, 9, 1, 4, 6, 8, 10, 5]
流程模拟:
初始数组 arr
:[3, 7, 2, 9, 1, 4, 6, 8, 10, 5],期望结果:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
选定数组的最后一个元素
5
作为基准值,也就是最终排序结果
应该是以5
为界限划分为左右两边且有序从左边开始,寻找比
5
大的值,然后与5
进行调换(比5
小的值保持原状,排在5
前面,比5
大的值与5
调换位置排5
的后面),此轮找到7
,将7
与5
调换,结束此次遍历。从右边开始,由于
7
已经是上一轮排好序的便不再动它,此轮从10
开始,向左遍历,寻找比5
小的值,然后与5
进行调换(比5
大的值保持原状,排在5
后面,比5
小的值与5
调换位置排5
的后前面),此轮找到4
,将4
与5
调换,结束此次遍历。从左边开始,由于
3
和4
都是前两轮已经排好序的便不再动它,从2
开始,向右遍历,寻找比5
大的值,然后与5
进行调换(道理同步骤1
),此轮找到9
,将9
与5
调换位置,结束此次遍历。从右边开始,从
1
开始,向右遍历,寻找比5
小的值,然后与5
进行调换(道理同步骤2
),此轮找到1
,将1
与5
调换,结束此次遍历。这个时候,
5
的左右两侧符合左侧值<=5
,右侧值>=5
,所以结束此轮排序。5
的左右两侧继续抽出来各自进行下一轮的排序,规则同上,直到无法再拆分下去,即完成了整体的快速排序。
快速排序核心之一:
public static int divide(int[] arr, int start, int end) {
int base = arr[end];
while (start < end) {
while (start < end && arr[start] <= base) {
start++;
}
if (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
end--;
}
while (start < end && arr[end] >= base) {
end--;
}
if (start < end) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
start++;
}
}
int borderPostion = start == end ? start : -1;
return borderPostion;
}
快速排序核心之二:
public static void sort(int[] arr, int start, int end) {
if (start > end) {
return;
} else {
int borderPostion = divide(arr, start, end);
sort(arr, start, borderPostion - 1);
sort(arr, borderPostion + 1, end);
}
}
完整代码如下:
package com.ggsddu.domain.sort;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class QuickSort {
public static void main(String[] args) {
int[] arr = new int[]{3, 7, 2, 9, 1, 4, 6, 8, 10, 5};
System.out.println("排序前:" + Arrays.toString(arr));
sort(arr, 0, arr.length - 1);
System.out.println("排序后:" + Arrays.toString(arr));
}
/**
* 快速排序
*
* @param arr
* @param start
* @param end
*/
public static void sort(int[] arr, int start, int end) {
if (start > end) {
return;
} else {
// 如果不止一个元素,继续划分两边递归排序下去
int borderPostion = divide(arr, start, end);
System.out.print(borderPostion + " ");// 以某个基准值为界每一次划分元素排序后,此基准值所在位置
System.out.println(Arrays.toString(arr));
sort(arr, start, borderPostion - 1);// 基准值左侧元素递归排序
sort(arr, borderPostion + 1, end);// 基准值右侧元素递归排序
}
}
/**
* 对数组某一段元素进行划分
* 以基准值为界,左侧数都大于基准值,右侧数都大于基准值
* 形象表示为:[{A|num<=基准值} 基准值 {B|num>=基准值}]
*
* @param arr
* @param start 开始遍历的位置
* @param end 基准值的初始位置
* @return 每一次划分元素,基准值所在位置
*/
public static int divide(int[] arr, int start, int end) {
int base = arr[end];// 默认以最右边的元素作为基准值
// 一旦start等于end,就说明左右两个指针合并到了同一位置,可以结束此轮循环
while (start < end) {
while (start < end && arr[start] <= base) {
start++;// 从左边开始向右遍历,如果如果遍历的值比基准值小,下标start就继续向右走
}
// 上面的while循环结束时,就说明当前的arr[start]的值比基准值大,应与基准值位置进行交换
if (start < end) {
//交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
// 此值与基准值交换位置后,被“排序”,并且“占领”了原end的位置,排序范围缩小,end向前移动一位
end--;
}
while (start < end && arr[end] >= base) {
end--;// 从右边开始遍历,如果遍历的值比基准值大,下标end就继续向左走
}
// 上面的while循环结束时,就说明当前的arr[end]的值比基准值小,应与基准值进行交换
if (start < end) {
// 交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
// 此值与基准值交换后,被“排序”,并且“占领”原start的位置,排序范围缩小,所以start同时向后移动一位
start++;
}
}
// 返回start或end皆可,因为此时start和end都为基准值所在的位置
int borderPostion = start == end ? start : -1;
return borderPostion;
}
}
控制台:
排序前:[3, 7, 2, 9, 1, 4, 6, 8, 10, 5]
4 [3, 4, 2, 1, 5, 9, 6, 8, 10, 7]
0 [1, 4, 2, 3, 5, 9, 6, 8, 10, 7]
2 [1, 2, 3, 4, 5, 9, 6, 8, 10, 7]
1 [1, 2, 3, 4, 5, 9, 6, 8, 10, 7]
3 [1, 2, 3, 4, 5, 9, 6, 8, 10, 7]
6 [1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
5 [1, 2, 3, 4, 5, 6, 7, 8, 10, 9]
8 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
7 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
9 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
排序后:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Process finished with exit code 0
算法优缺点
快速排序最“快”的地方在于左右两边能够快速同时递归排序下去,所以最优的情况是基准值刚好取在无序区的中间,这样能够最大效率地让两边排序,同时最大地减少递归划分的次数。此时的时间复杂度仅为 O(NlogN)
。
快速排序也有存在不足的情况,当每次划分基准值时,得到的基准值总是当前无序区域里最大或最小的那个元素,这种情况下基准值的一边为空,另一边则依然存在着很多元素(仅仅比排序前少了一个),此时时间复杂度为 O(N*N)
。
选择排序
动图:
插入排序
动图: