(五)冒泡排序 & 归并算法

一. 冒泡排序

• 基本思想：从第一个数开始逐个往后比较，保证最小的数在最前面
• 复杂度：O(N*N)
• 实现：

/**
     * 排序方法：冒泡排序
     * 复杂度：O(N*N)
     * 特点：挨个往后冒，不符合规则则交换
     * */
    public static void maoPao(ArrayList<Integer>arrayList){
        for(int i=0;i<arrayList.size();i++){
            int needToMin = arrayList.get(i);
            for(int j=i+1;j<arrayList.size();j++){
                int needToComp = arrayList.get(j);
                if(needToMin>needToComp){
                    int temp =arrayList.get(i);
                    arrayList.set(i, arrayList.get(j));
                    arrayList.set(j, temp);
                    needToMin = arrayList.get(i);
                }
            }
        }
    }

 

二. 归并排序

• 基本思想：将数组分成2组A，B，对于A，B两组再各自分成2组，直到分出来的小组只有1个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的2个小组就可以了。从而实现通过局部有序达到全局有序。
• 复杂度：O(N*logN)
• 实现：

public class Example {

    private static int inversePairsSum = 0;

    private static int InversePairs(int[] array) {
        divideGroup(array, 0, array.length - 1);
        return inversePairsSum;
    }

    private static void divideGroup(int[] array, int start, int end) {
        if (start >= end) {
            return;
        }
        int middle = start + (end - start) / 2;
        divideGroup(array, start, middle);
        divideGroup(array, middle + 1, end);
        mergeData(array, start, middle, end);
    }

    /**
     * 相当于[start,middle]区间是有序的，[middle+1, end]是有序的，现在就是要将两个有序的区间合为一个
     * (1)建立一个临时数组，存放数据
     * (2)将临时数组数据替换array
     */
    private static void mergeData(int[] array, int start, int middle, int end) {

        int[] temp = new int[end - start + 1];

        int before = start, after = middle + 1, tempIndex = 0;

        // 区间内比较完毕
        while (before <= middle && after <= end) {
            if (array[before] < array[after]) {
                temp[tempIndex++] = array[before++];
            } else {
                temp[tempIndex++] = array[after++];
                // 统计逆序对
                inversePairsSum = inversePairsSum + end - after + 1;
            }
        }
        // 如果有剩下的数，直接放入即可
        while (before <= middle) {
            temp[tempIndex++] = array[before++];
        }
        while (after <= end) {
            temp[tempIndex++] = array[after++];
        }

        // 替换原数组
        for (int i = 0; i < temp.length; i++) {
            array[start + i] = temp[i];
        }
    }


    public static void main(String[] args) {
        int[] array = new int[]{123,34,21,3,56,787};
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        InversePairs(array);
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

}