數據結構複習之排序算法複習（冒泡and插入）Java版

排序算法複習

一、冒泡排序

冒泡排序：重複遍歷要排序的數列，每次比較兩個元素，如果位置錯誤就將其交換。因爲像泡泡浮出水面，故而名曰冒泡排序。

步驟：

• 每次從數列底部選擇一個元素，與其上一個元素進行比較。
• 內層循環控制將一個元素排序
• 外層循環控制總共需要排序元素總數

優化：

• 在排序中中途可能即已經有序，此時不會交換元素，但是還有元素仍未被排序，所以會進行一些無意義的循環
• 當有序時不交換元素，設置標誌位，如果已經有序則停止循環

代碼如下：

package SortTest;

import java.util.Random;

public class BubblingSortTest {
    public static void main(String[] args) {
        BubblingSortTest bubblingSortTest = new BubblingSortTest();
        int[] buildelement = bubblingSortTest.buildelement();
        //未優化
        int[] bullingsorted = bubblingSortTest.bullingsorted(buildelement);
        //已優化
        //int[] bullingsorted = bubblingSortTest.optimizationSorted();
        bubblingSortTest.printSort(bullingsorted);
    }
    //建立長度爲10的測試數組
    public int[] buildelement(){
        int[] element = new int[10];
        Random random = new Random();
        for (int i=0;i<10;i++){
            //生成0-10之間的隨機數
            element[i] = random.nextInt(10);
        }
        return element;
    }
    //冒泡排序
    public int[] bullingsorted(int[] element){
        int temp=0;
        for(int i=0;i<element.length;i++){
            for(int j=0;j<element.length;j++){
                if(element[j]<element[j+1]){
                    temp = element[j];
                    element[j] = element[j+1];
                    element[j+1] = temp;
                }
            }
        }
        return element;
    }
    //冒泡排序優化
    public int[] optimizationSorted(int[] element){
        int temp=0;
        boolean flag = true;
        for(int i=0;i<element.length;i++){
            for(int j=0;j<element.length;j++){
                if(element[j]<element[j+1]){
                    temp = element[j];
                    element[j] = element[j+1];
                    element[j+1] = temp;
                    flag = false;
                }
            }
            if(flag){
                break;
            }
        }
        return element;
    }
    //結果輸出
    public void printSort(int[] element){
        for (int i=0;i<element.length;i++){
            System.out.print(element[i]+" ");
        }
    }
}

冒泡排序總結：

• 時間複雜度：O(n^2)、最好情況時間複雜度O(n)、最壞時間複雜度O(n2)
• 空間複雜度：O(1) 冒泡排序是一種原地排序算法
• 穩定性：穩定（當排序中有值相等的元素，在排序中不交換其位置則爲穩定排序算法）

二、插入排序

插入排序：將數列分爲兩個區間，已排序區間和未排序區間。初始已排序區間有一個元素（因爲一個元素一定是有序的）。插入算法核心就是將未排序區間中提取元素放入已排序區間的適當位置中，以保證已排序區間始終有序。最終未排序區間元素全部移動到已排序區間，算法結束。

步驟：

• 從第一個元素開始，認爲該元素已經被排序
• 取出下一個元素，和已排序區元素進行比較
• 如果該未排序元素小於已排序元素，則將該元素向前移動
• 重複三步驟，直到找到合適位置
• 取下一元素重複以上步驟

代碼如下：

package SortTest;

import java.util.Random;

public class InsertSortTest {
    public static void main(String[] args) {
        InsertSortTest insertSortTest = new InsertSortTest();
        int[] buildelement = insertSortTest.buildelement();
        int[] insertSorted = insertSortTest.insertSorted(buildelement);
        insertSortTest.printSort(insertSorted);
    }
    //建立長度爲10的測試數組
    public int[] buildelement(){
        int[] element = new int[10];
        Random random = new Random();
        for (int i=0;i<10;i++){
            //生成0-10之間的隨機數
            element[i] = random.nextInt(10);
        }
        return element;
    }
    //插入排序算法
    public int[] insertSorted(int[] element){
        if (element.length <= 1){
            return element;
        }
        for (int i=1;i<element.length;i++){
            int next = element[i];
            //有序區的最後一個元素下標，每循環一次有序區大小增加一
            int preIndex = i - 1;
            while (preIndex >= 0 && element[preIndex] > next){
                //有序區元素向後移動一位
                element[preIndex+1] = element[preIndex];
                //preIndex--是爲了讓該元素與下一個有序區元素比較
                preIndex--;
            }
            //如果找到位置後 由於上面的程序特性會多進行一次preIndex--，所以這裏要+1
            element[preIndex+1] = next;
        }
        return element;
    }
    //結果輸出
    public void printSort(int[] element){
        for (int i=0;i<element.length;i++){
            System.out.print(element[i]+" ");
        }
    }
}

圖示：

插入排序總結：

• 時間複雜度：O(n^{2)、最好時間複雜度O(n)、最壞時間複雜度O(n}2)

• 空間複雜度：O(1)

• 穩定性：穩定

後續排序算法會逐步更新。
新人起步，分享所學。