【数据结构】Java实现冒泡排序、插入排序、选择排序、归并排序

1、核心思想

（1）交换排序（冒泡排序）：每一轮下沉一个最大的数，每一轮比较的次数随着轮数越多而越来越少（因为需要比较的元素越来越少，较大数渐渐沉入底部）
（2）插入排序：初始时将第一个元素看作是有序表，遍历剩余元素，将每一个元素插入该有序表中。
（3）选择排序：初始时将整个表看作是无序区，遍历整个表找到最小值，将其放到无序区的第一位，然后将该位元素“踢出”无序区。
（4）归并排序：需要注意三种情况，即是：

• 当全是长度为length的偶数个表，那么：两两合并
• 当含有“孤表”的偶数个表（“孤表”就是长度不为length的表），那么：两两合并，但需要和第一种情况分开
• 当是奇数个表，合并前偶数个表，剩下一个表（可能是“孤表”，也可能是长度为length的表），那么：不用合并，留到下一趟合并
  且：整个归并排序中，每一轮合并只会存在一张“孤表”。（“孤表”是笔者方便表达所创概念，非专业术语）

2、代码实现

import java.util.Random;

public class Test {

    public static void main(String[] args) {
        int[] data1 = new int[10];
        int[] data2 = new int[10];
        int[] data3 = new int[10];
        int[] data4 = new int[10];
        createArray(data1);
        createArray(data2);
        createArray(data3);
        createArray(data4);
        System.out.printf("---交换排序（冒泡排序）---\n随机生成%d个随机数：\n", data1.length);
        printArray(data1);
        System.out.println("\n排序后：");
        MPSort(data1);
        printArray(data1);
        System.out.printf("\n---插入排序---\n随机生成%d个随机数：\n", data2.length);
        printArray(data2);
        System.out.println("\n排序后：");
        CRSort(data2);
        printArray(data2);
        System.out.printf("\n---选择排序---\n随机生成%d个随机数：\n", data3.length);
        printArray(data3);
        System.out.println("\n排序后：");
        XZSort(data3);
        printArray(data3);
        System.out.printf("\n---归并排序---\n随机生成%d个随机数：\n", data4.length);
        printArray(data4);
        System.out.println("\n排序后：");
        GBSort(data4);
        printArray(data4);
    }

    public static void createArray(int[] arr) {
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = random.nextInt(21);
        }
    }

    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.printf("%d\t", arr[i]);
        }
    }

    /*交换-冒泡排序*/
    public static void MPSort(int[] arr) {
        int i, j, temp;
        for (i = arr.length-1; i >= 1; i--) {
            for (j = 0; j < i; j++) {
                if (arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] =temp;
                }
            }
        }
    }

    /*插入排序*/
    public static void CRSort(int[] arr) {
        int i, j, temp;
        for (i = 1; i < arr.length; i++) {
            j = i - 1;
            temp = arr[i];
            while (j >= 0 && arr[j] > temp) {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = temp;
        }
    }

    /*选择排序*/
    public static void XZSort(int[] arr) {
        int i, j, k, temp;
        for (i = 0; i < arr.length; i++) {
            k = i; // k是最小的
            for (j = i + 1; j < arr.length; j++){
                if (arr[j] < arr[k]) {
                    k = j;
                }
            }
            if (k != i) {
                temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
    }

    /*参数说明：low~mid是第一个表，mid+1~high是第二个表*/
    public static void TwoListSort(int[] arr, int low, int mid, int high) {
        int[] temp = new int[10];
        int i = low, j = mid + 1, k = 0, r;
        while (i <= mid && j <= high) {
            if (arr[i] < arr[j]) {
                temp[k] = arr[i];
                i++;
                k++;
            }
            else {
                temp[k] = arr[j];
                j++;
                k++;
            }
        }
        while (i <= mid) {
            temp[k] = arr[i];
            i++;
            k++;
        }
        while (j <= high) {
            temp[k] = arr[j];
            j++;
            k++;
        }
        for (k = 0, r = low; r <= high; k++, r++) {
            arr[r] = temp[k];
        }
    }

    /*归并排序*/
    public static void GBSort(int[] arr) {
        int i;
        for (int len = 1; len < arr.length; len *= 2) {
            for (i = 0; i + 2 * len - 1 < arr.length; i += 2*len) {
                TwoListSort(arr, i, i + len - 1, i + 2 * len - 1);
            }
            if (i + len < arr.length) {
                TwoListSort(arr, i, i + len - 1, arr.length - 1);
            }
        }
    }

}

3、运行结果