常見的八種排序方法

八種排序的時間複雜度：

排序法	平均時間	最差情形	穩定度	額外空間	備註
冒泡	O(n2)	O(n2)	穩定	O(1)	n小時較好
選擇	O(n2)	O(n2)	不穩定	O(1)	n小時較好
插入	O(n2)	O(n2)	穩定	O(1)	大部分已排序時較好
基數	O(logRB)	O(logRB)	穩定	O(n)	B是真數(0-9)， <p>R是基數(個十百)</p> </td> </tr><tr><td>Shell</td> <td>O(nlogn)</td> <td>O(ns) 1<s<2</td> <td>不穩定</td> <td>O(1)</td> <td>s是所選分組</td> </tr><tr><td>快速</td> <td>O(nlogn)</td> <td>O(n2)</td> <td>不穩定</td> <td>O(nlogn)</td> <td>n大時較好</td> </tr><tr><td>歸併</td> <td>O(nlogn)</td> <td>O(nlogn)</td> <td>穩定</td> <td>O(1)</td> <td>n大時較好</td> </tr><tr><td>堆</td> <td>O(nlogn)</td> <td>O(nlogn)</td> <td>不穩定</td> <td>O(1)</td> <td>n大時較好</td> </tr></tbody></table></div><p> </p>

冒泡排序（Bubble Sort）:

傳統的冒泡排序需要依次比較相鄰的兩個元素，按照升序或者降序的規則進行交換，如要讓 3 2 1三個數進行升序排序，首先從3開始跟2比較大於2進行交換，然後在與1進行比較，進行交換，第一趟排序結果就是2 1 3；然後 2與1比較大於1交換，2與3比較小於3不變。這就是冒泡排序的原理。然而，如果是讓 3 2 1進行降序排序呢，還要再從頭到尾比較一邊豈不是很浪費空間，此時我們就可以使用一個 flag標記來對冒泡排序進行排序。具體方法我們來看一下代碼。

演示：

代碼：

一般的冒泡排序：


int arr[]={6,2,3,4,0};
        int change=0;
 
        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]){
                
                    change=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=change;
                }
            }
 
       
 
            System.out.println("第"+(i+1)+"趟"+Arrays.toString(arr));
        }

通過標記 flag來判斷是否進行了交換，如果沒有則直接退出循環，從而達到了對排序的進一步優化。

優化後的冒泡排序：


int arr[]={6,2,3,4,0};
        int change=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;
                    change=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=change;
                }
            }
 
            if(!flag){
                break;
            }else {
                flag=false;
            }
 
            System.out.println("第"+(i+1)+"趟"+Arrays.toString(arr));
        }

選擇排序（Select Sort）：

第一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，然後再從剩餘的未排序元素中尋找到最小（大）元素，然後放到已排序的序列的末尾。以此類推，直到全部待排序的數據元素的個數爲零。選擇排序是不穩定的排序方法。

假設序列第一個位置爲最小，然後依次和後面的元素進行比較，比第一個元素小的元素就設個標記再往後依次比較，直到找到最小值然後與第一個位置元素進行交換。

演示：

代碼：


    int[] arry= {7,4,8,3};
        for(int i = 0;i<arry.length-1;i++){
            int minIndex=i;
            int minArry=arry[i];
 
            for (int j = i+1;j<arry.length;j++){
                if(minArry>arry[j]){
                    minIndex=j;
 
                    minArry=arry[j];
 
                }
 
            }
            if(minIndex!=i){
                arry[minIndex]=arry[i];
                arry[i]=minArry;
            }
            System.out.println(Arrays.toString(arry));
        }

用過代碼我們不難發現冒泡排序和選擇排序的時間複雜度都是O(n²)，接下來我們看一下他們的區別：

（1）冒泡排序是比較相鄰位置的兩個數，而選擇排序是按順序比較，找最大值或者最小值；

（2）冒泡排序每一輪比較後，位置不對都需要換位置，選擇排序每一輪比較都只需要換一次位置；

（3）冒泡排序是通過數去找位置，選擇排序是給定位置去找數；

冒泡排序優缺點：優點:比較簡單，空間複雜度較低，是穩定的；
缺點:時間複雜度太高，效率慢；

選擇排序優缺點：優點：一輪比較只需要換一次位置；

缺點：效率慢，不穩定（舉個例子5，8，5，2，9 我們知道第一遍選擇第一個元素5會和2交換，那麼原序列中2個5的相對位置前後順序就破壞了）

插入排序（Inser Sort）：

插入排序的基本操作就是將一個數據插入到已經排好序的有序數據中，從而得到一個新的、個數加一的有序數據，算法適用於少量數據的排序，時間複雜度爲O(n^2)。是穩定的排序方法。

在一個數組中我們開始把第一個元素看爲是一個排好序的隊列，剩餘的看爲是亂序的序列，在剩餘的隊列中依次選取元素與前面隊列進行比較再爾進行排序，至此我們就保證前面的元素永遠都是有序的，從而達到插入排序的效果。

演示：

代碼：


    int arry[]={7,5,4,3,2};
 
        for(int i=1;i<arry.length;i++){
            int insertVal = arry[i];
            int insertIndex=i-1;
 
            while(insertIndex >= 0 && insertVal<arry[insertIndex]){
                arry[insertIndex+1]=arry[insertIndex];
                insertIndex--;
            }
                arry[insertIndex+1]=insertVal;
      
            System.out.println(Arrays.toString(arry));
        }

優化後的代碼：

優化後的代碼我們可以發現，通過insertIndex是否變化來判斷while循環是否執行，從而避免不必要的賦值。


    int arry[]={7,5,4,3,2};
 
        for(int i=1;i<arry.length;i++){
            int insertVal = arry[i];
            int insertIndex=i-1;
 
            while(insertIndex >= 0 && insertVal<arry[insertIndex]){
                arry[insertIndex+1]=arry[insertIndex];
                insertIndex--;
            }
            if(insertIndex+1!=i){ //此時無需交換
                arry[insertIndex+1]=insertVal;
            }
 
            System.out.println(Arrays.toString(arry));
        }

希爾排序（Shell Sort）：

對於簡單插入排序，存在一個效率的問題如2,3,4,5,1這個數組，使用插入排序他的順序是

{2 3 4 5 5}
{2 3 4 4 5}
{2 3 3 4 5}
{2 2 3 4 5}
{1 2 3 4 5} 不難看出我們只需要換一個數然後過程執行了五次，對效率有很大影響，此時我們可以引入一種改進後的插入排序，那就是希爾排序，也叫縮小增量排序。

希爾排序就是按照下標一定增量進行分組，每組再按照直接插入算法排序，隨着組的減少，每組的元素也越來越少，當組數減少至爲1時，整個文件分成1組，算法便終止。

演示：

代碼：

（交換法）


package sort;
 
import java.util.Arrays;
 
public class ShellSort {
    public static void main(String[] args) {
        int temp=0;
        int arry[]={3,2,1,6,5,7,8,4,9,0};
        // gap代表分了多少組
        for(int gap =arry.length/2;gap>0;gap/=2){
            //i代表第幾組開始是 第0 6個 1 7個  2 8個 3 9個 4 10個爲一組
            for (int i=gap;i<arry.length;i++){
                //j代表第幾組的第幾個元素
                for(int j=i-gap;j>=0;j-=gap){
                    if(arry[j]>arry[j+gap]){
                        temp=arry[j];
                        arry[j]=arry[j+gap];
                        arry[j+gap]=temp;
                    }
                }
            }
            System.out.println(Arrays.toString(arry));
        }
 
    }
}

（移步法）


  int arry[]={3,2,1,6,5,7,8,4,9,0};
 
 
        // gap代表分了多少組
        for(int gap =arry.length/2;gap>0;gap/=2){
            //i代表第幾組開始是 第0 6個 1 7個  2 8個 3 9個 4 10個爲一組 共五個組那麼0 和6肯定爲一組
            for (int i=gap;i<arry.length;i++){
            int j=i;
            int temp=arry[j];
            if(arry[j]<arry[j-gap]){
                 while(j-gap>=0 && temp < arry[j - gap]){
                     arry[j]=arry[j-gap];
                     j-=gap;
                 }
                 arry[j]=temp;
            }
            }
            System.out.println(Arrays.toString(arry));
        }
    }

快速排序（Quick Sort）：

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。大致意思就是在一個數組中取中間元素比它小的方左邊比它大的則放右邊兩邊元素再按照快排要求，最終變成有序序列。

演示：

代碼：


public static void quickSort(int[] arr, int left, int right) {
		int l = left;// 左下標
		int r = right;// 右下標
		int pivot = arr[(left + right) / 2];// 找到中間的值
		// 將比pivot小的值放在其左邊，比pivot大的值放在其右邊
		while (l < r) {
			// 在pivot左邊尋找，直至找到大於等於pivot的值才退出
			while (arr[l] < pivot) {
				l += 1;// 將l右移一位
			}
			// 在pivot右邊尋找，直至找到小於等於pivot的值才退出
			while (arr[r] > pivot) {
				r -= 1;// 將r左移一位
			}
			if (l >= r) {
				// 左右下標重合，尋找完畢，退出循環
				break;
			}
			// 交換元素
			int temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
 
			//倘若發現值相等的情況，則沒有比較的必要，直接移動下標即可
		
			// 如果交換完後，發現arr[l]==pivot，此時應將r左移一位
			if (arr[l] == pivot) {
				r -= 1;
			}
			// 如果交換完後，發現arr[r]==pivot，此時應將l右移一位
			if (arr[r] == pivot) {
				l += 1;
			}
		}
		// 如果l==r，要把這兩個下標錯開，否則會出現無限遞歸，導致棧溢出的情況
		if (l == r) {
			l += 1;
			r -= 1;
		}
		// 向左遞歸
		if (left < r) {
			quickSort(arr, left, r);
		}
		// 向右遞歸
		if (right > l) {
			quickSort(arr, l, right);
		}
	}

歸併排序（Merge Sort）：

歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序算法,該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲二路歸併。

演示：

代碼：


public static void mergeSort(int[] arr, int left, int right, int[] temp) {
		// 分解
		if (left < right) {
			int mid = (left + right) / 2;// 中間索引
			// 向左遞歸進行分解
			mergeSort(arr, left, mid, temp);
			// 向右遞歸進行分解
			mergeSort(arr, mid + 1, right, temp);// mid + 1，中間位置的後一個位置纔是右邊序列的開始位置
			// 每分解一輪便合併一輪
			merge(arr, left, right, mid, temp);
		}
	}
 
	/**
	 * 合併的方法
	 * 
	 * @param arr   待排序的數組
	 * @param left  左邊有序序列的初始索引
	 * @param right 中間索引
	 * @param mid   右邊有序序列的初始索引
	 * @param temp  做中轉的數組
	 */
	public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
		int i = left; // 初始化i，左邊有序序列的初始索引
		int j = mid + 1;// 初始化j，右邊有序序列的初始索引(右邊有序序列的初始位置即爲中間位置的後一個位置)
		int t = 0;// 指向temp數組的當前索引，初始爲0
		// 先把左右兩邊的數據(已經有序)按規則填充到temp數組
		// 直到左右兩邊的有序序列，有一邊處理完成爲止
		while (i <= mid && j <= right) {
			// 如果左邊有序序列的當前元素小於或等於右邊有序序列的當前元素，就將左邊的元素填充到temp數組中
			if (arr[i] <= arr[j]) {
				temp[t] = arr[i];
				t++;// 索引後移
				i++;// i後移
			} else {
				// 反之，將右邊有序序列的當前元素填充到temp數組中
				temp[t] = arr[j];
				t++;// 索引後移
				j++;// j後移
			}
		}
		// 把有剩餘數據的一邊的元素填充到temp中
		while (i <= mid) {
			// 此時說明左邊序列還有剩餘元素
			// 全部填充到temp數組
			temp[t] = arr[i];
			t++;
			i++;
		}
		while (j <= right) {
			// 此時說明左邊序列還有剩餘元素
			// 全部填充到temp數組
			temp[t] = arr[j];
			t++;
			j++;
		}
		// 將temp數組的元素複製到原數組
		t = 0;
		int tempLeft = left;
		while (tempLeft <= right) {
			arr[tempLeft] = temp[t];
			t++;
			tempLeft++;
		}
	}

基數排序（radix sort）：

基數排序會分配是個桶標號分別是0-9，在第一次排序時會將每個元素的個位取出，放到相應編號的桶中，然後按照桶的順序依次放回原來的數組；進行第二次排序時，會將每個元素的十位取出放到相應編號的桶中，然後按照桶的順序依次放回原來的數組；以此類推直到最高位排完，排序也就完成。

演示：

數組{718，34，72，401，64}進行基數排序

第一趟排序結果{ 401 ，72 ，34 ， 64，718}

第二趟排序結果{401，718，34，64，72}

第三趟排序結果{34，64，72，401，718} 排序完成將元素返回原數組

代碼：


public static void raixSort(int[] arr) {
		// 第一輪(針對每個元素的個位進行排序處理)
 
		// 定義一個二維數組，模擬桶，每個桶就是一個一維數組
		// 爲了防止放入數據的時候桶溢出，我們應該儘量將桶的容量設置得大一些
		int[][] bucket = new int[10][arr.length];
		// 記錄每個桶中實際存放的元素個數
		// 定義一個一維數組來記錄每個桶中每次放入的元素個數
		int[] bucketElementCounts = new int[10];
 
		for (int j = 0; j < arr.length; j++) {
			// 取出每個元素的個位
			int digitOfElement = arr[j] % 10;
			// 將元素放入對應的桶中
			// bucketElementCounts[digitOfElement]就是桶中的元素個數，初始爲0，放在第一位
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			// 將桶中的元素個數++
			// 這樣接下來的元素就可以排在前面的元素後面
			bucketElementCounts[digitOfElement]++;
		}
		// 按照桶的順序取出數據並放回原數組
		int index = 0;
		for (int k = 0; k < bucket.length; k++) {
			// 如果桶中有數據，才取出放回原數組
			if (bucketElementCounts[k] != 0) {
				// 說明桶中有數據，對該桶進行遍歷
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出元素放回原數組
					arr[index++] = bucket[k][l];
				}
			}
			// 第一輪處理後，需要將每個bucketElementCounts[k]置0
			bucketElementCounts[k] = 0;
		}
		System.out.println("第一輪:" + Arrays.toString(arr));
 
		// ----------------------------
 
		// 第二輪(針對每個元素的十位進行排序處理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每個元素的十位
			int digitOfElement = arr[j] / 10 % 10;
			// 將元素放入對應的桶中
			// bucketElementCounts[digitOfElement]就是桶中的元素個數，初始爲0，放在第一位
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			// 將桶中的元素個數++
			// 這樣接下來的元素就可以排在前面的元素後面
			bucketElementCounts[digitOfElement]++;
		}
		// 按照桶的順序取出數據並放回原數組
		index = 0;
		for (int k = 0; k < bucket.length; k++) {
			// 如果桶中有數據，才取出放回原數組
			if (bucketElementCounts[k] != 0) {
				// 說明桶中有數據，對該桶進行遍歷
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出元素放回原數組
					arr[index++] = bucket[k][l];
				}
			}
			// 第二輪處理後，需要將每個bucketElementCounts[k]置0
			bucketElementCounts[k] = 0;
		}
		System.out.println("第二輪:" + Arrays.toString(arr));
 
		// ----------------------------
 
		// 第三輪(針對每個元素的百位進行排序處理)
		for (int j = 0; j < arr.length; j++) {
			// 取出每個元素的百位
			int digitOfElement = arr[j] / 100 % 10;
			// 將元素放入對應的桶中
			// bucketElementCounts[digitOfElement]就是桶中的元素個數，初始爲0，放在第一位
			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
			// 將桶中的元素個數++
			// 這樣接下來的元素就可以排在前面的元素後面
			bucketElementCounts[digitOfElement]++;
		}
		// 按照桶的順序取出數據並放回原數組
		index = 0;
		for (int k = 0; k < bucket.length; k++) {
			// 如果桶中有數據，才取出放回原數組
			if (bucketElementCounts[k] != 0) {
				// 說明桶中有數據，對該桶進行遍歷
				for (int l = 0; l < bucketElementCounts[k]; l++) {
					// 取出元素放回原數組
					arr[index++] = bucket[k][l];
				}
			}
			// 第三輪處理後，需要將每個bucketElementCounts[k]置0
			bucketElementCounts[k] = 0;
		}
		System.out.println("第三輪:" + Arrays.toString(arr));
	}

        <div class="person-messagebox">
            <div class="left-message"><a href="https://blog.csdn.net/qq_42183409">
                <img src="https://profile.csdnimg.cn/D/0/F/3_qq_42183409" class="avatar_pic" username="qq_42183409">
            </a></div>
            <div class="middle-message">
                                    <div class="title"><span class="tit "><a href="https://blog.csdn.net/qq_42183409" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;,&quot;ab&quot;:&quot;new&quot;}" target="_blank">Ysdo</a></span>
                    <!-- 等級，level -->
                                            <img class="identity-icon" src="https://csdnimg.cn/identity/blog5.png">                                            </div>
                <div class="text"><span>原創文章 181</span><span>獲贊 41</span><span>訪問量 9萬+</span></div>
            </div>
                            <div class="right-message">
                                        <a class="btn btn-sm attented bt-button personal-watch" data-report-click="{&quot;mod&quot;:&quot;popu_379&quot;,&quot;ab&quot;:&quot;new&quot;}">已關注</a>
                                                            <a href="https://im.csdn.net/im/main.html?userName=qq_42183409" target="_blank" class="btn btn-sm bt-button personal-letter">私信
                    </a>
                                </div>
                        </div>
                    
    </div>

常見的八種排序方法

八種排序的時間複雜度：

冒泡排序（Bubble Sort）:

選擇排序（Select Sort）：

插入排序（Inser Sort）：

希爾排序（Shell Sort）：

快速排序（Quick Sort）：

歸併排序（Merge Sort）：

基數排序（radix sort）：

2020前端必看JS面試題

原生Ajax五個步驟

前端解決惡意訪問的幾個方法

小程序頁面跳轉，帶參數跳轉，以及navigator跳轉

計算機網絡知識面試彙總(超詳細)

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結