冒泡排序和归并排序

目的:

该文章实现了常见的

冒泡排序

	非线性,容易理解

归并排序

	线性,效率高,使用递归

仅供个人记忆使用.

import java.util.Arrays;
import java.util.Random;

/**
 * 归并排序算法和冒泡排序
 * 记录-方便记忆
 *
 * @Author liud
 * @Date 2019/9/10 9:21
 **/
public class SortTest {
    /**
     * 定义一个10w 的数组
     */
    public static int[] arr = new int[100000];
    public final static Random random = new Random();

    static {
        // 塞随机值
        for (int i = 0; i < 100000; i++) {
            arr[i] = random.nextInt();
        }
    }

    public static void main(String[] args) {

        // 归并排序 10w排序只要 35ms
        long start2 = System.currentTimeMillis();
        int[] mergeSort = merge_sort(arr);
        System.out.println(System.currentTimeMillis() - start2);
        // sout_p(mergeSort);

        // 冒泡排序  10w数字排序要 18s(18617ms)
        long start1 = System.currentTimeMillis();
        bubblesort(arr);
        System.out.println(System.currentTimeMillis() - start1);

    }

    private static void sout_p(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    // =====================================================================================================================

    /**
     * 归并排序-算法
     *
     * @param arr
     * @return
     */
    private static int[] merge_sort(int[] arr) {
        if (arr.length == 1) {
            return arr;
        }
        int[] left = Arrays.copyOfRange(arr, 0, arr.length / 2);
        int[] right = Arrays.copyOfRange(arr, arr.length / 2, arr.length);

        left = merge_sort(left);
        right = merge_sort(right);
        // 比较左右数组的值,
        int[] merge = mergearr(left, right);
        return merge;
    }

    /**
     * 比较左右数组的值, 将其按顺序放到c 数组
     * a ={1,4,7}, b ={2,3,6,10}--> c ={1,2,3,4,6,7,10}
     *
     * @param a
     * @param b
     * @return c 数组,存放 a,b 数组 排序后的值
     */
    private static int[] mergearr(int[] a, int[] b) {
        // c数组 长度是 a,b长度相加 ,容易理解
        int[] countarr = new int[a.length + b.length];
        int mi = 0, ai = 0, bi = 0;
        // a b 数组 ,谁的值小,就放到数组c ,c数组角标++  | 对应的数组角标也要++,因为要比较对应数组的下一个值了
        while (ai < a.length && bi < b.length) {
            if (a[ai] <= b[bi]) {
                countarr[mi] = a[ai];
                ai++;
            } else {
                countarr[mi] = b[bi];
                bi++;
            }
            mi++;
        }
        //  a数组或者 b数组 已经全部塞到c 数组了 ,剩下的那个数组就直接塞到c数组 ,不需要再比较了
        if (ai < a.length) {
            for (int i = ai; i < a.length; i++) {
                countarr[mi] = a[i];
                mi++;
            }
        } else if (bi < b.length) {
            for (int i = bi; i < b.length; i++) {
                countarr[mi] = b[i];
                mi++;
            }
        }
        return countarr;
    }

    // =====================================================================================================================

    /**
     * 冒泡排序
     * 第一次比较后,最大的数排到了最后
     * i: 比较的轮数  (一轮只能比较出一个最大数 ,所以轮数 是数组长度-1, 为啥减一 ?? 如果只有两个数 ,比较一次就行)
     * j: 一轮比较多少个数
     * 关键点: 最后一个数可以不再排序,节省时间
     *
     * @param arr
     */
    private static void bubblesort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j);
                }
            }
        }
    }

    private static void swap(int[] arr, int j) {
        int temp;
        temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
    }

    // =====================================================================================================================

}