Java中的選擇排序和冒泡排序思想及代碼實作

選擇排序

選擇排序基本思想(假設從大到小排序)：

初始化一個數組：int[] array={n個資料}

第1次排序：将索引為0的元素取出來，用該元素與之後的每一個元素做比較，比該元素小則不動，比該元素大則交換二者的數值，依次比較到最後，這樣最大值就放到了索引為0的位置

第2次排序：将索引為1的元素取出來，用該元素與之後的每一個元素做比較，比該元素小則不動，比該元素大則交換二者的數值，依次比較到最後，這樣數組中第二大值就放到了索引為1的位置

依次類推，将倒數第2個元素取出來，與最後一個元素做比較，比該元素小則不動，比該元素大則交換二者的位置

// 用代碼實作上述思想
public class SelectSort {
    public static void main(String[] args) {
        // 靜态初始化一個int類型的數組
        int[] array = {,,,,};

        // 第1次排序：取索引為0的元素與之後的元素做比較
        for (int x = ; x < array.length; x++) {
            if (array[] < array[x]) {
                int temp = array[];
                array[] = array[x];
                array[x] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
        // 輸出結果為:[43, 1, 4, 6, 23]

        // 第2次排序：取索引為1的元素與之後的元素做比較
        for (int x = ; x < array.length; x++) {
            if (array[] < array[x]) {
                int temp = array[];
                array[] = array[x];
                array[x] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
        // 輸出結果為：[43, 23, 1, 4, 6]

        // 第3次排序：取索引為2的元素與之後的元素做比較
        for (int x = ; x < array.length; x++) {
            if (array[] < array[x]) {
                int temp = array[];
                array[] = array[x];
                array[x] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
        // 輸出結果為：[43, 23, 6, 1, 4]

        // 第4次排序：取索引為3的元素與之後的元素做比較
        for (int x = ; x < array.length; x++) {
            if (array[] < array[x]) {
                int temp = array[];
                array[] = array[x];
                array[x] = temp;
            }
        }
        System.out.println(Arrays.toString(array));
        // 輸出結果為：[43, 23, 6, 4, 1]
    }
}
           

觀察上面的代碼，我們發現如下規律：

1、for循環内容格式一樣

2、排序次數為：數組長度-1(依次取出數組前n-1個元素與之後的元素做比較，最後一個不用取出)

3、每次排序，需要進行比較的次數為：從取出索引位置後面第一個元素開始到末尾，即從i+1次開始，到array.length-1

改進後的代碼

// i 控制排序次數，取值從0到array.length-2，最後一個元素不用取出
        for(int i =  ;i<array.length-;i++) {  

        /* j 控制每次排序比較次數，每次比較從取出來要比較的值後面第一個元素
        開始，到該數組最後一個元素比較結束，是以每次比較j從i+1開始，到
        array.length-1結束*/

            for(int j = i+;j<array.length;j++) { 
                if(array[i]<array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                    count++;
                }
            }
        }
        System.out.println(Arrays.toString(array));
           

冒泡排序

冒泡排序基本思想(假設從大到小排序)：

第一次排序：将數組中的元素從0索引開始，兩兩做比較，數值較小者往後放，這樣最小值就到了數組末尾

第二次排序：從0索引開始，兩兩做比較，數值較小者往後放，一直比到倒數第二個數，這樣數組中第二小的數就放到了倒數第二的位置

依次類推，最後依次比較0索引和1索引兩個位置元素的大小，較小者往後放

代碼實作如下：

public class BubbleSort {
    public static void main(String[] args){
        //初始化一個數組
        int[] arr = {,,,,};

        //外層for循環代表排序次數，數組長度為arr.length-1，共比較arr.length-2次；
        for(int i = ;i<arr.length-;i++) {

            //内層for循環代表每次排序比較的次數，每次都是從0索引開始比較；
            //第一次從0比到arr.length-1,比較arr.length-2-0次;
            //第二次從0到arr.length-2，比較arr.length-2-1次;
            //......
            for(int j = ;j<arr.length--i;j++) {
                if(arr[j]<arr[j+]) {
                    int temp = arr[j];
                    arr[j] = arr[j+];
                    arr[j+] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
//輸出結果為：[43, 23, 6, 4, 1]
           

選擇排序和冒泡排序

選擇排序是把每次比出來的結果往前放，冒泡排序是把每次比出來的結果往後放。

關于這兩把排序方法，最主要的是掌握其思想，具體推理過程無須掌握，知道如何使用即可。