插入排序( 穩定排序，時間複雜度為O(n^2) )

一堆數字，從左向右依次遍歷，從第二個元素開始，與左邊的一個元素相比較，插入合適的位置，然後繼續遍歷第三個元素，與左邊兩個元素比較並插入，然後遍歷第四個，第五個... ...，一直到整個陣列排序完成，示例圖及程式碼如下:

package baseSort;

import java.util.Scanner;

public class DirectInsertSort {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int array[] = new int[10];    //定義一個數組
        System.out.println("請輸入要排序的數:");
        for(int index = 0; index < 10; index++) {  //用一個迴圈控制陣列的元素輸入
            int i = sc.nextInt();
            array[index] = i;
        }

        directInsertSort(array);
        printArray(array);
    }

    public static void directInsertSort(int[] array) {
        int i = 0;
        int j = 0;
        int t = 0;
        for(i = 1; i < array.length; i++) {  //從下標為1的第二個元素開始遍歷
            int tmp = array[i];   //建立臨時變數，儲存需要插入的元素值
            for(j = 0; j < i && array[j] <= tmp; j++) {  //找到應該插入的位置
            }

            for(t = i; t > j; t--) {   //將插入位置後面的元素後移一位
                array[t] = array[t - 1];
            }
            array[j] = tmp;   //將元素值插入最終位置
        }
    }

    public static void printArray(int[] array) {  //列印陣列元素的方法
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.print("\n");
    }
}
 

選擇排序( 非穩定排序，時間複雜度為O(n^2) )

一堆數字，從下標為0開始找，找出最小的一個數，放在下標為0的位置，再從下標為1的位置開始找最小的數，放在下標為1的位置，再從下標為2的位置開始找，找出最小的數放在下標為2的位置上......，直至將數字完全排序，示例圖及程式碼如下     

package baseSort;

import java.util.Scanner;

public class DirectSelectSort {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int array[] = new int[10];    //定義一個數組
        System.out.println("請輸入要排序的數:");
        for(int index = 0; index < 10; index++) {  //用一個迴圈控制陣列的元素輸入
            int i = sc.nextInt();
            array[index] = i;
        }

        directSelectSort(array);
        printArray(array);
    }

    public static void directSelectSort(int[] array) {
        for(int i = 0; i < array.length - 1; i++) {  //從下標為0開始選擇
            int minIndex = i;   //將當前位置記為最小數的下標
            for(int j = i + 1; j < array.length; j++) {  //將當前位置的數與之後的數相比較
                if(array[minIndex] > array[j]) {  //如果當前小標的值比最小下標的值更小，則更改當前下標為最小下標
                    minIndex = j;
                }
            }

            if(minIndex != i) {   //遍歷完之後，如果下標和初始下標不同，則表明初始下標的值不是最小值
                int tmp = array[i];   //故交換兩下標的值
                array[i] = array[minIndex];
                array[minIndex] = tmp;
            }
        }
    }

    public static void printArray(int[] array) {  //列印陣列元素的方法
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.print("\n");
    }
}
 

交換排序(氣泡排序)( 穩定排序，時間複雜度為O(n^2) )

從下標為0開始，相鄰兩元素進行比較，並交換為小在前，大在後，直至排序完成，如圖中方法，以此類推，程式碼如下

package baseSort;

import java.util.Scanner;

public class DirectSwapSort {
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        int array[] = new int[10];    //定義一個數組
        System.out.println("請輸入要排序的數:");
        for(int index = 0; index < 10; index++) {  //用一個迴圈控制陣列的元素輸入
            int i = sc.nextInt();
            array[index] = i;
        }

        directSwapSort(array);
        printArray(array);
    }

    public static void directSwapSort(int[] array) {
        for(int i =0; i < array.length - 1; i++) {  //一共length個元素，則需要比較length-1次
            for(int j = 0; j < array.length - 1; j++) {   //從下標為0開始向後比較
                if(array[j] > array[j + 1]) {  //如果前面的元素比後面的大，則值交換
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

    public static void printArray(int[] array) {  //列印陣列元素的方法
        for(int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "  ");
        }
        System.out.print("\n");
    }
}