冒泡算法、插入算法、選擇算法

轉自https://www.cnblogs.com/onepixel/articles/7674659.html

 

 

1、冒泡排序（Bubble Sort）

冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。 

1.1 算法描述

• 比較相鄰的元素。如果第一個比第二個大，就交換它們兩個；
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
• 針對所有的元素重複以上的步驟，除了最後一個；
• 重複步驟1~3，直到排序完成。

1.2 動圖演示

1.3 代碼實現

    public static int[] bubbleSort(int [] arr){
        System.out.println("冒泡前：\t\t\t"+Arrays.toString(arr));
        System.out.println();
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    // 相鄰元素兩兩對比
                    int temp = arr[j+1];        // 元素交換
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
            System.out.println("第"+(i+1)+"遍循環的結果是："+Arrays.toString(arr));
        }
        System.out.println();
        return arr;
    }

2、選擇排序（Selection Sort）

選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。 

2.1 算法描述

n個記錄的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。具體算法描述如下：

• 初始狀態：無序區爲R[1..n]，有序區爲空；
• 第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別爲R[1..i-1]和R(i..n）。該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R[i+1..n)分別變爲記錄個數增加1個的新有序區和記錄個數減少1個的新無序區；
• n-1趟結束，數組有序化了。

2.2 動圖演示

　　

2.3 代碼實現

    public static int[] selectionSort(int[] arr) {
        System.out.println("選擇前：\t\t\t"+Arrays.toString(arr));
        System.out.println();
        int len = arr.length;
        int minIndex;
        int temp;
        for (int i = 0; i < len - 1 ; i++) {
            minIndex = i;
            for (int j = i+1 ; j<len ; j++ ) {
                int arr_j = arr[j];
                int arr_minIndex = arr[minIndex];
                if ( arr_j < arr_minIndex ){
                    minIndex = j;
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
            System.out.println("第"+(i+1)+"遍循環的結果是："+Arrays.toString(arr));
        }
        System.out.println();
        return arr;
    }

2.4 算法分析

表現最穩定的排序算法之一，因爲無論什麼數據進去都是O(n2)的時間複雜度，所以用到它的時候，數據規模越小越好。唯一的好處可能就是不佔用額外的內存空間了吧。理論上講，選擇排序可能也是平時排序一般人想到的最多的排序方法了吧。

 

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。

3.1 算法描述

一般來說，插入排序都採用in-place在數組上實現。具體算法描述如下：

• 從第一個元素開始，該元素可以認爲已經被排序；
• 取出下一個元素，在已經排序的元素序列中從後向前掃描；
• 如果該元素（已排序）大於新元素，將該元素移到下一位置；
• 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
• 將新元素插入到該位置後；
• 重複步驟2~5。

3.2 動圖演示

3.3 代碼實現

    public static int[] insertionSort(int[] arr) {
        System.out.println("插入前：\t\t\t"+Arrays.toString(arr));
        System.out.println();

        int len  = arr.length;
        int preIndex;//前一個元素的索引
        int current ;//當前元素的值
        for (int i = 1 ;i<len;i++){
            preIndex = i -1;
            current = arr[i];

            int arr_preIndexValue = arr[preIndex];//前一個元素的值
            while (preIndex >= 0 && arr[preIndex]> current){
                //當前小於前一個，元素互換位置
                arr[preIndex+1] = arr[preIndex];
                preIndex -- ;
            }
            arr[preIndex + 1] = current;

            System.out.println("第"+(i)+"遍循環的結果是："+Arrays.toString(arr));
        }

        return arr;
    }

3.4 算法分析

 

插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。