排序算法（分类，时间复杂度）（快速排序，插入排序，希尔排序，选择排序，冒泡排序）
2019-10-30 10:24:06 诗诗文要努力呀 阅读数 49 收藏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shaunan/article/details/102813922
1.排序算法
1.排序的分类
分为内部排序和外部排序，其中内部排序分为插入排序、选择排序、交换排序、归并排序和基数排序。插入排序包括直接插入排序和希尔排序；选择排序包括简单选择排序和堆排序；交换排序包括冒泡排序和快速排序。
2.算法的时间复杂度
由小到大为：
常数阶O(1)
对数阶O(log2n)
线性阶O(n)
线性对数阶O(nlog2n)
平方阶O(n^2)
立方阶O(n^3)
k次方阶O(n^k)
指数阶O(2^n)
2.冒泡排序
1.基本思想：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
2.优化
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较。
在这里插入图片描述
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class BubbleSort1 {
public static void main(String[] args) {
// int arr[] ={3,9,-1,10,20};
//测试一下冒泡排序的速度O(n^2),给80000个数据
//创建一个80000个随机的数组
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int)(Math.random() * 8000000);
}
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyy-MM-dd HH:mm:ss”);
String date1Str = simpleDateFormat.format(data1);
System.out.println(“排序前的时间是：”+date1Str);
//测试冒泡排序
bubbleSort(arr);
//输出排序后的数组
// System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是："+date2Str);
}
//将前面的冒泡排序算法，封装成一个方法
public static void bubbleSort(int[] arr){
//冒泡排序，时间复杂度O（n^2）
int temp = 0;//临时变量
boolean flag = false;//表示变量，表示是否进行过交换
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]){
flag = true;
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
// System.out.println(“第”+(i+1)+“趟排序后的数组”);
// System.out.println(Arrays.toString(arr));
if (!flag ){//在一趟排序中，一次交换都没有发生过
break;
}else {
flag = false;//重置flag,进行下次判断
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
3.选择排序
1.基本思想：第一次从arr[0]arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]arr[n-1]中选取最小值，与arr[1]交换，，第三次从arr[2]arr[n-1]中选取最小值，与arr[2]交换，，，，第i次从arr[i-1]arr[n-1]中选取最小值，与arr[i-1]交换，.，，第n-1次从arr[n-2]~arr[n-1]中选取n-最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
在这里插入图片描述
2.思路
1）选择排序一共有数组大小-1轮排序
2）每1轮排序，又是一个循环，循环的规则
①先假定当前这个数是最小数
②然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
③当遍历到数组的最后时，就得到本轮最小数和下标
④交换
在这里插入图片描述
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class SelectSort {
public static void main(String[] args) {
// int[] arr = {101, 34, 119, 1,7,2};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int)(Math.random() * 8000000);
}
System.out.println("排序前");
//System.out.println(Arrays.toString(arr));
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是："+date1Str);
selectSort(arr);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是："+date2Str);
// System.out.println("排序后");
// System.out.println(Arrays.toString(arr));
}
//选择排序
public static void selectSort(int[] arr) {
//可以直接用for来解决
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {//说明假定的最小值不是最小
min = arr[j];
minIndex = j;
}
}
//交换一下，将最小值放在arr[0]
if(minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
// System.out.println("第"+(i+1)+"轮后~~");
//System.out.println(Arrays.toString(arr));
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
4.插入排序
1。基本思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，把它插入到有序表中的适当位置，使之成为新的有序表。
在这里插入图片描述
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class InsertSort {
public static void main(String[] args) {
// int[] arr = {101, 34, 119, 1,-3,6};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int)(Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是："+date1Str);
//System.out.println(Arrays.toString(arr));
insertSort(arr);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是："+date2Str);
}
//插入排序
public static void insertSort(int[] arr) {
//使用for循环
for (int i = 1; i < arr.length; i++) {
//定义待插入的数
int insertVal = arr[i];
int insertIndex = i - 1;//即arr[1]的前面这个数的下标
//给insertVal找到插入的位置
//说明1。insertIndex >=0保证在给insertVal找插入位置，不越界
//2.insertVal < arr[insertIndex]待插入的数，还没有找到插入位置
//3.就需要将arr[insertIndex]后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insertIndex + 1
if(insertIndex +1 != i){
arr[insertIndex + 1] = insertVal;
}
//System.out.println("第"+i+"轮插入后");
// System.out.println(Arrays.toString(arr));
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
5.希尔排序
在这里插入图片描述
1）希尔排序时，对有序序列在插入时采用交换法，并测试排序速度
2）希尔排序时，对有序序列在插入时采用移动法，并测试排序速度
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class ShellSort {
public static void main(String[] args) {
//int[] arr = {2, 9, 4, 10, 38, 5, 1, 18, 22, 7};
int[] arr = new int[8];
for (int i = 0; i < 8; i++) {
arr[i] = (int)(Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是："+date1Str);
// shellSort(arr);//交换式
shellSort2(arr);//移位式
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
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++) {
//遍历各组中所有的元素（每组两个元素），步长5
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));
}
}
//对交换式的希尔排序进行优化->移位法
public static void shellSort2(int[] arr){
//增量gap，并逐步的缩小增量
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素，逐个对其所在的组进行直接插入排序
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;
}
//当推出while后，就给temp找到插入的位置
arr[j] = temp;
}
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
6.快速排序
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达成整个数据变成有序序列。
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class QuickSort {
public static void main(String[] args) {
// int[] arr = {-9,78,0,23,-45,67,-5,800,43};
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int)(Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是："+date1Str);
quickSort(arr,0,arr.length-1);
//System.out.println("arr="+ Arrays.toString(arr));
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是："+date2Str);
}
public static void quickSort(int[] arr, int left, int right){
int l = left;
int r = right;
//pivot中轴
int pivot = arr[(left + right)/2];
int temp =0;//临时变量交换时使用
//循环的目的是让比中轴值小的放在左边，大的放在右边
while (l < r){
//pivot左边找大于等于pivot值，才推出
while (arr[l]<pivot){
l+=1;
}
while (arr[r]>pivot){
r -= 1;
}
//成立说明pivot左右的值已经按照左边全部是小于等于pivot值
if (l >= r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后
if (arr[l] == pivot){//前移
r-=1;
}
if (arr[r] == pivot){//前移
l +=1;
}
//向左递归
if (left < r){
quickSort(arr,left,r);
}
if (right > l){
quickSort(arr,l,right);
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
扫一扫
3794
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
