氣泡排序演算法

比較相鄰的元素，如果第一個比第二個大，就交換他們兩個。

對每一組相鄰元素做同樣的工作，從開始第一對到結尾的最後一對，最後的元素應該會是最大的樹。

針對所有的元素重複以上的步驟，除了最後一個。

持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

相同元素的前後順序並沒有改變，所以氣泡排序是一種穩定的排序演算法。

public static void main(String[] args) {
        int[] nums = {13, 99, 53, 32, 46, 61};
        int len = nums.length;

        // 外迴圈控制輪數
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    nums[j] = nums[j] + nums[j + 1];
                    nums[j + 1] = nums[j] - nums[j + 1];
                    nums[j] = nums[j] - nums[j + 1];
                }
            }
        }

        for (int x : nums) {
            System.out.println(x);
        }
    }
 

選擇排序演算法

每一趟從待排序的資料元素中選出最小（或者最大）的一個元素，順序放在已排好序的最後，直到全部待排序的資料元素排完。選擇排序是不穩定的排序方法。

public static void main(String[] args) {
        int[] nums = {13, 99, 53, 32, 46, 61};  // 需要排序的數列
        int len = nums.length;  // 陣列長度
        int minIndex = 0;
    	// 排序
        for (int i = 0; i < len - 1; i++) {
            minIndex = i;
            for (int j = (i + 1); j < len; j++) {
                // 如果當前的下標的值小於假設的最小值就記錄這個最小值的下標
                if (nums[j] < nums[minIndex]) {
                    minIndex = j;
                }
            }
			// 交換假設最小值和實際最小值的位置
            if (minIndex != i) {
                nums[i] = nums[i] + nums[minIndex];
                nums[minIndex] = nums[i] - nums[minIndex];
                nums[i] = nums[i] - nums[minIndex];

            }
        }
		// 列印
        for(int x: nums){
            System.out.println(x);
        }
    }
 

直接插入排序演算法

基本思想：每步將一個待排序的記錄，按其順序碼大小插入到前面已經排序的字序列的合適位置(從後向前找到合適位置後)，直到全部插入排序完為止。

public static void main(String[] args) {
        int[] nums = {34, 4, 56, 17, 90, 65};  // 待排序的陣列

        for (int i = 0; i < nums.length; i++) {
            int temp = nums[i];  // 記錄假定的最小值
            int j = 0;

            // 依次對假定的最小值的前面的元素進行比較
            for (j = i - 1; j >= 0; j--) {
                if (nums[j] > temp) {
                    // 如果前面的元素大於假定最小值就往後移動一位
                    nums[j + 1] = nums[j];
                } else {
                    // 如果假定最小值比前面的數大則說明比前面所有的數都大
                    break;
                }
            }
            // 插入temp的值
            if (nums[j + 1] != temp) {
                nums[j + 1] = temp;
            }
        }
        // 列印
        for (int x : nums) {
            System.out.println(x);
        }
    }
 

二分查詢演算法

二分法查詢又叫做折半查詢，前提是在已經排好序的陣列中，通過將待查詢的元素與中間索引值對應的元素進行比較，若大於中間索引值對應的元素，去右半部分查詢，否則，去左半部分查詢。以此類推，直到找到為止，找不到返回一個負數。

    public static void main(String[] args) {
        // 必須保證數列是有序的
        int[] nums = {10, 20, 50, 65, 88, 90};
        int index = binarySearch(nums, 100);
        System.out.println(index);
    }

    /***
     * 二分查詢演算法
     * @param nums 數列集合
     * @param key 關鍵字
     * @return 查詢到的位置下標
     */
    public static int binarySearch(int[] nums, int key) {
        int start = 0; // 開始下標
        int end = nums.length - 1; // 結束下標
        while (start <= end) {
            // 得到兩個數的的中間值
            int middle = (start + end) / 2;
            if (nums[middle] > key) {
                // 如果要查詢的數小於中間值就去左半邊查詢
                end = middle - 1;
            } else if (nums[middle] < key) {
                // 如果要查詢的數大於中間值就去右半邊查詢
                start = middle + 1;
            } else {
                // 如果要查詢的數等於中間值，直接返回middle 下標
                return middle;
            }
        }
        // 迴圈結束也沒找到，返回-1
        return -1;
    }