算法二分查找冒泡排序选择排序插入排序

Posted 2021-04-07 昊天码字

1.二分查找：每次在有序的数组砍一半，时间复杂度为O(log以n为底2的对数)。

 

2.冒泡排序：从0开始，0和1比较；1和2比较……，排出一个最大数在n-1位置上，再从0到n-2开始排序，时间复杂度为O(n的平方)。

 

1. public class Code_00_BubbleSort {  

2.       

3.     public static void bubbleSort(int[] arr) {  

4.         if(arr == null || arr.length < 2) {  

5.             return;  

6.         }  

7.         for(int end = arr.length - 1; end > 0; end--){  

8.             for(int i = 0; i < end; i++) {  

9.                 if(arr[i] > arr[i+1]) {  

10.                     swap(arr, i, i + 1);  

11.                 }  

12.             }  

13.         }  

14.     }  

15.     public static void swap(int[] arr, int i, int j) {  

16.         int top = arr[i];  

17.         arr[i] = arr[j];  

18.         arr[j] = top;  

19.     }  

20.   

21. }  

3.选择排序：从0开始依次和1、2……n-1比较，挑出一个最小的放在0上；再从1到n-1挑出一个最小的放在1上，时间复杂度为O(n的平方)。

1. import java.util.Arrays;  

2.   

3. public class Code_02_SelectionSort {  

4.     public static void selectionSort(int[] arr) {  

5.         if(arr == null || arr.length < 2) {  

6.             return;  

7.         }  

8.         for(int i = 0; i < arr.length - 1; i++) {  

9.             int minindex = i;  

10.             for(int j = i + 1; j < arr.length; j++) {  

11.                 minindex = arr[j] < arr[minindex] ? j : minindex;  

12.             }  

13.             swap(arr, i, minindex);  

14.         }  

15.     }  

16.   

17.     public static void swap(int[] arr, int i, int j) {  

18.         int top = arr[i];  

19.         arr[i] = arr[j];  

20.         arr[j] = top;  

21.     }  

22.   

23. }  

4.插入排序：就好像抓扑克一样，抓第一张，不排序；抓第二张，排序；抓第三张，把第三张扑克牌插入到前二张中。所以就是从前一个数排序开始，到前二个数排序，一直到前n个数排序。最好时间复杂度（已经排好序的）就是O(n)，最坏时间复杂度就是O(n的平方)。当数据不同从而产生的算法复杂度不同时，一律按最差的估计。

1. import java.util.Arrays;  

2.   

3. public class Code_01_InsertSort {  

4.     public static void insetSort(int[] arr) {  

5.         if(arr == null || arr.length < 2){  

6.             return;  

7.         }  

8.         for(int i = 1; i < arr.length; i++) {  

9.             for(int j = i + 1; j >= 0 && arr[j] > arr[j + 1]; j--) {  

10.                 swap(arr, j, j + 1);  

11.             }  

12.         }  

13.     }  

14.     public static void swap(int[] arr, int i, int j) {  

15. //      arr[i] = arr[i] ^ arr[j];  

16. //      arr[j] = arr[i] ^ arr[j];  

17. //      arr[i] = arr[i] ^ arr[j];  

18.         int top = arr[i];  

19.         arr[i] = arr[j];  

20.         arr[j] = top;  

21.     }  

22. }  

5.冒泡排序和选择排序与数据无关，任何数据都是O(n的平方)。