數據結構和算法——排序算法（上）

1、冒泡排序

冒泡排序：冒泡排序是依次比較待排序序列中相鄰的倆個元素大小，將較大的元素和較小的元素交換位置，這樣一輪比較下來，序列中最大值的數就會置於序列最後，然後重複第二輪比較將第二大的數放在倒數第二位以此類推，最終會得到一個有序序列。冒泡排序是使值較大的元素逐漸從前移向後部，就象水底下的氣泡一樣逐漸向上冒，因此得名。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 6, 84, 2, 46, 7};
        BubbleSort(arr);
        System.out.println("冒泡排序之後的結果：" + Arrays.toString(arr));
    }

    public static void BubbleSort(int[] arr) {
        int temp = 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;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第" + (i + 1) + "趟排序後的數組");
            System.out.println(Arrays.toString(arr));
            //冒泡排序優化
            if (!flag) {//一趟排中如果沒有發生過交換直接退出
                break;
            } else {//發生過交換就重置繼續進行下一輪
                flag = false;
            }
        }
    }
}

 2、選擇排序

選擇排序：選擇排序是從一個待排序序列中，在一輪排序中選擇出一個最小的數將其置於第一位，第二輪排序選擇一個第二小的數置於第二位，以此類推，最後就會產生一個有序序列。

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {1, 3, 6, 84, 2, 46, 7};
        selectSort(arr);
        System.out.println("選擇排序結果爲：" + Arrays.toString(arr));
    }

    public static void selectSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            int minVal = arr[i];
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < minVal) {
                    minIndex = j;
                    minVal = arr[j];
                }

            }
            //第一輪結束後，將找到的最小值與第一位置的元素進行交換
            if (minIndex != i) {
                arr[minIndex] = arr[i];
                arr[i] = minVal;
            }
        }
    }
}

 3、插入排序

插入排序：將一個待排序序列看成一個有序列表和一個無序列表，有序列表只有一個數，無序列表是剩餘的數，每次從無序列表中拿出一個數插入到有序列表進行比較，將較小的數排在有序列表的前面，以此類推就可以達到排序的目的。

 

public class InsertSort {
    static int count = 0;
    public static void main(String[] args) {

        int[] arr = {3,1,0};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println("插入排序一共排了："+count+"次");
    }


    public static void insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertVal = arr[i];
            //定義索引。即開始時有序表的位置，待插入得數需要加入到有序表中
            int insertIndex = i-1;
            while (insertIndex >= 0 && insertVal < arr[insertIndex]){
                arr[insertIndex+1] = arr[insertIndex];
                insertIndex--;
            }

            count++;
            if (insertIndex+1 != i) {
                arr[insertIndex + 1] = insertVal;
            }
        }
    }

4、快速排序

快速排序：快速排序是對冒泡排序的一種改進，先計算出數列的中間值，經過排序將中間值的左邊爲的集合比中間值小的，右邊爲集合比中間值大的，然後依次這樣在兩邊分別遞歸排序，結束後就得到一個有序序列。

public class QuickSort {
    public static void main(String[] args) {

        int[] arr = {5, 2, 0, -1, 6, 3};
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left;//左下標
        int r = right;//右下標
        int pivot = arr[(left + right) / 2];
        int temp = 0;

        while (l < r) {
            //在pivot的左邊一直找，找到大於等於pivot值才退出
            while (arr[l] < pivot) {
                l += 1;
            }
            //在pivot的右邊一直找，找到小於等於pivot值才退出
            while (arr[r] > pivot) {
                r -= 1;
            }
            //如果l >= r 說明pivot的左右倆個值，已經按照左邊全是小於等於pivot的
            //右邊全是大於等於pivot值
            if (l >= r) {
                break;
            }
            //開始交換
            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 必須l++，r--；否則會出現棧溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }
        //向左遞歸
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右遞歸
        if (right > l) {
            quickSort(arr, l, right);
        }
    }
}