图解

1. 选择排序

    /*
     * 选择排序 
     * 
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
     * 以此类推，直到所有元素均排序完毕。
     */
    int[] num = {2,3,1,5,4};
    //控制遍历次数
    for (int i = 0; i < num.length-1; i++) {
        //记录每次遍历的起始下标位置，默认为最小值
        int minIndex = i;
        for (int j = i+1; j < num.length; j++) {
            if (num[j]<num[i]) {
                minIndex = j;
            }
        }
        //每次遍历结束，最小值和起始位置互换值
        int temp = num[i];
        num[i] = num[minIndex];
        num[minIndex] = temp;
    }
    //打印输出
    for (int i : num) {
        System.out.print(i+"\t");
    }

2. 冒泡排序

    /*
     * 冒泡排序
     * 
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
     * 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
     */
    int[] num1 = {1,3,4,6,2,11,19,2,7,0};
    // 控制遍历次数
    for (int i = 0; i < num1.length-1; i++) {
        int temp = 0;
        //控制每次遍历比较次数
        for (int j = 0; j < num1.length-1; j++) {
            //如果后一个数更小就和前一个数交换值
            if (num1[j+1]<num1[j]) {
                temp = num1[j];
                num1[j] = num1[j+1];
                num1[j+1] = temp;
            }
        }
        //打印每次遍历之后的数组
        System.out.println("第"+(i+1)+"次遍历后的数组：");
        for (int j : num1) {
            System.out.print(j+" ");
        }
        System.out.println();
    }
    //输出
    System.out.println("经过冒泡排序后的数组：");
    for (int i : num1) {
        System.out.print(i+" ");
    }

3. 直接插入排序

    /*
     * 直接插入排序 
     * 
     * 从第一个元素开始，该元素可以认为已经被排序
     * 取出下一个元素，在已经排序的元素序列中从后向前扫描
     * 如果前面元素大，则前面元素向后移一位
     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
     * 将新元素插入到该位置中
     * 重复步骤2
     */
    int[] num2 = {3, 4, 2, 1, 5, 6, 9, 8, 7, 0 };
    //控制遍历次数
    for (int i = 1; i < num2.length; i++) {
        int temp = num2[i];
        int j = i;
        for (j = i; j > 0 && temp < num2[j-1]; j--) {
            //num[2] = 2时
            //j=2;num2[2]=num2[1];3 4 4 ...;j=1;继续内层循环
            //j=1;num2[1]=num2[0];3 3 4 ...;j=0;跳出内层循环
            num2[j] = num2[j-1];
        }
        //j=0;num[0]=2;2,3,4...
        num2[j] = temp;
        //打印每次移动后的数组
        System.out.println("第"+i+"次移动后的数组:");
        for (int k : num2) {
            System.out.print(k+" ");
        }
        System.out.println();
    }
    //输出
    System.out.println("经过直接插入排序之后的数组：");
    for (int i : num2) {
        System.out.print(i+" ");
    }

4. 阶乘

/*
 * 阶乘的方法递归算法
 * 
 * 1!   = 1 
 * 2!   = 2 x 1             = 2 x 1！ 
 * 3!   = 3 x 2 x 1         = 3 x 2! 
 * 4!   = 4 x 3 x 2 x 1     = 4 x 3! 
 * ......
 */ 
static int factorial(int n) {
    // return n*(n-1)!
    if (n < 1) {
        return 0;
    }
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

5. 归并排序

/*    
    （1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 
    （2）设定两个指针，最初位置分别为两个已经排序序列的起始位置 
    （3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置 
    （4）重复步骤3直到某一指针达到序列尾 
    （5）将另一序列剩下的所有元素直接复制到合并序列尾
*/
public static void merge(int[] num, int low, int mid, int high) {
    int[] temp = new int[high - low + 1];
    int left = low;// 左边数组的起始位置
    int right = mid + 1;// 右边数组的起始位置
    int index = 0;
    // 比较拆分的两个子数组，依次取最小值，放入新数组,并移动指针到后一位
    while (left <= mid && right <= high) {
        if (num[left] < num[right]) {
            temp[index++] = num[left++];
        } else {
            temp[index++] = num[right++];
        }
    }
    // 把左边剩余的数移入数组
    while (left <= mid) {
        temp[index++] = num[left++];
    }
    // 把右边边剩余的数移入数组
    while (right <= high) {
        temp[index++] = num[right++];
    }
    // 把新数组中的数覆盖nums数组
    for (int i = 0; i < temp.length; i++) {
        num[i + low] = temp[i];
    }
    System.out.println(Arrays.toString(temp));
}

public static int[] mergeSort(int[] num, int low, int high) {
    int mid = (low + high) / 2;
    if (low < high) {
        // 递归拆分左边
        mergeSort(num, low, mid);
        // 递归拆分右边
        mergeSort(num, mid + 1, high);
        // 左右归并,将拆分的有序数组排序
        merge(num, low, mid, high);
        System.out.println(Arrays.toString(num));
    }
    return num;
}

public static void main(String[] args) {
    int[] num3 = {14,12,15,13,11,16};
    int[] num0 = mergeSort(num3, 0, num3.length-1);
    System.out.println("排序结果：" + Arrays.toString(num0));
}

5. 排序算法2