1.二分查找
二分查找也稱爲折半查找，它是一種效率較高的查找方法。二分查找的使用前提是線性表已經按照大小排好了序。這種方法充分利用了元素間的次序關係，採用分治策略。基本原理是：首先在有序的線性表中找到中值，將要查找的目標與中值進行比較，若是目標小於中值，則在前半部分找，若是目標小於中值，則在後半部分找；假設在前半部分找，則再與前半部分的中值相比較，若是小於中值，則在中值的前半部分找，若是大於中值，則在後半部分找。以此類推，直到找到目標爲止。 算法
假設咱們要在 2，6，11，13，16，17，22，30中查找22，上圖所示，則查找步驟爲：sql
首先找到中值：中值爲13（下標：int middle = (0+7)/2），將22與13進行比較，發現22比13大，則在13的後半部分找；
在後半部分 16，17，22，30中查找22，首先找到中值，中值爲17（下標：int middle=(0+3)/2），將22與17進行比較，發現22比17大，則繼續在17的後半部分查找；
在17的後半部分 22，30查找22，首先找到中值，中值爲22（下標：int middle=(0+1)/2），將22與22進行比較，查找到結果。
二分查找大大下降了比較次數，二分查找的時間複雜度爲：O(logn)，即。數組
示例代碼： 併發
public class BinarySearch { public static void main(String[] args) { int arr[] = {2, 6, 11, 13, 16, 17, 22, 30}; System.out.println("非遞歸結果,22的位置爲:" + binarySearch(arr, 22)); System.out.println("遞歸結果,22的位置爲:" + binarySearch(arr, 22, 0, 7)); } //非遞歸 static int binarySearch(int[] arr, int res) { int low = 0; int high = arr.length-1; while(low <= high) { int middle = (low + high)/2; if(res == arr[middle]) { return middle; }else if(res <arr[middle]) { high = middle - 1; }else { low = middle + 1; } } return -1; } //遞歸 static int binarySearch(int[] arr,int res,int low,int high){ if(res < arr[low] || res > arr[high] || low > high){ return -1; } int middle = (low+high)/2; if(res < arr[middle]){ return binarySearch(arr, res, low, middle-1); }else if(res > arr[middle]){ return binarySearch(arr, res, middle+1, high); }else { return middle; } } }
其中冒泡排序加個標誌，因此最好狀況下是o(n)app
直接選擇排序：高併發
排序過程：
1 、首先在全部數據中通過 n-1次比較選出最小的數，把它與第 1個數據交換，
二、而後在其他的數據內選出排序碼最小的數，與第 2個數據交換...... 依次類推，直到全部數據排完爲止。
在第i 趟排序中選出最小關鍵字的數據，須要作 n-i次比較。
//冒泡排序，大的數不斷向後冒泡 void buddle(vector<int>& nums) { int len=nums.size(); for(int i=0;i<len-1;i++) { for(int j=0;j<len-1-i;j++) { if(nums[j]>nums[j+1]) swap(nums[j],nums[j+1]); } } }
線性排序算法
計數排序
假設：有n個數的集合，並且n個數的範圍都在0~k(k = O(n))之間。
運行時間：Θ(n+k)
待排序數組A如圖2.1所示，須要輔助數組B(存儲最後排序結果)，數組C(存儲元素的個數)。基於上述的假設，數組C的大小爲k，C[i]表示數組A中元素i(0 <= i < k)的個數(如圖2.2所示)，爲了保證計數排序的穩定性，數組C變化爲圖2.3，C[i]表示小於或者等於i的個數。代碼以下：
1: /* 2: 輸入：待排序數組A,存儲排序後的數組B，數組A的大小，數組C的大小 3: 功能：計數排序 4: */ 5: void CountingSort(int A[], int B[], int len, int k) 6: { 7: int *CountArr = new int[k]; 8: int i; 9: for (i = 0; i < k; i++) 10: { 11: CountArr[i] = 0; 12: } 13: 14: for (i = 0; i < len; i++) 15: { 16: CountArr[A[i]]++; 17: } 18: 19: for (i = 1; i < k; i++) 20: { 21: CountArr[i] += CountArr[i-1]; 22: } 23: 24: // 從右至左保證算法的穩定性 25: for (i = len-1; i >=0; i--) 26: { 27: B[CountArr[A[i]]-1] = A[i]; 28: CountArr[A[i]]--; 29: } 30: }
9-12行和19-22行的運行時間Θ(k)，14-17行和25-29行的運行時間爲Θ(n)，因此總的運行時間爲Θ(2(n+k)) = Θ(n+k)。
基數排序
基數排序：將全部待比較數值(正整數)統一爲一樣的數位長度，數位較短的數前面補零。而後，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成之後， 數列就變成一個有序序列。
基數排序分爲兩種LSD和MSD。
LSD(Least significant digital)：最低有效位優先，即從右向左開始排序。
MSD(Most significant digital)：最高有效位優先，即從左往右開始排序。
如下是LSD方式的基數排序的僞代碼
1: RadixSort(A,d)
2: for i <- 1 to d
3: 用穩定的排序算法排列數組A中元素的第i位
如圖3：先牌個位，而後十位，最後百位。爲數組的某一位排序的時候必定須要穩定的算法。
運行時間爲Θ(d(n+k))。在基數排序中排列數組各位的算法是計數排序因此運行時間爲Θ(n+k)，又d是數組中數的最大位數。
桶排序
桶排序：將數組分到有限個桶子內，而後再對桶子裏面的序列進行排序，運行時間Θ(n)。桶排序基於一個假設：輸入的數據由隨機過程構成，不然在最壞狀況下都分配到一個桶子裏面，若是又不知足計數排序的假設要求，那麼只能使用基於比較的排序算法進行排序，運行時間就退化到Ω(nlogn)。
排序算法穩定性
排序算法穩定性：假設待排序序列中有兩個元素相等，並且在排序前和排序後兩個相等的元素的相對位置不變，即有 a = b，排序前a在b前面，那麼排序後，a仍是要在b前面。排序算法的穩定性是要看具體的算法實現，好比通常狀況下，直接選擇排序，快速排序，希爾排序，堆排序都不是穩定排序算法，基數排序，計數排序，歸併排序，插入排序，冒泡排序都是穩定排序算法。
快速排序：A = {2， 2， 1}，排序後A = {1，2，2}。
希爾排序：A = {1，2，5，4，4，7}，排序後（k = 2）；A = {1， 2， 4， 4， 5， 7} 。
堆排序：A = {2，2，1}，排序後A = {1，2， 2}。
直接選擇排序： A = {4， 4， 2， 5},排序後 A = {2，4， 4， 5}。
以上舉例都不知足穩定性。