归并排序及其merge和part函数以及应用逆序对

// 使用分治法
// 归并排序的merge函数和part函数可以应用在其他地方
int main() {
    int a[] = {3,6,7,2,5};
    merge_sort(a, 5);

    return 0;
}

int merge_sort(int a[], int n) {
    if (a == nullptr || n <= 0) {
        return -1;
    }

    int ret = merge_sort_part(a, 0, n-1);
    if (ret < 0) {
        return ret;
    }

    return 0;
}

int merge_sort_part(int a[], int left, int right) {
    if (left >= right) {
        return 0;
    }

    int mid = (left + right)/2;
    merge_sort_part(a, left, mid);
    merge_sort_part(a, mid+1, right);
    int ret = merge(a, left, mid, right);
    if (ret < 0) {
        return ret;
    }

    return 0;
}

int merge(int a[], int left, int mid, int right) {
    if (!(a != nullptr && left <= mid && mid <= right)) {
        return -1;
    }

    int i = left;
    int j = mid + 1;
    int k = 0;
    int n = right - left + 1;
    int *array = new int[n];
    while (i <= mid && j <= right) {
        if (a[i] <= a[j]) {
            array[k] = a[i];
            k++;
            i++;
        } else {
            array[k] = a[j];
            k++;
            j++;
        }
    }

    while (i <= mid) {
        array[k] = a[i];
        k++;
        i++;
    }

    while (j <= right) {
        array[k] = a[j];
        k++;
        j++;
    }

    for (i = 0; i < n; i++, left++) {
        a[left] = array[i];
    }

    delete [] array;
    return 0;
}

// 应用
// 数组中的逆序对
// 传统的方法是遍历每一个数和其后的数组成，同时需要考虑去重，算法时间复杂度为O(n^2)
// 使用归并排序的思路：
// 把数组分割成为两两一对，判断逆序对后，归并，归并两个对过程中，判断逆序对，需要比较大小判断逆序对后排序归并，再递归
// 注意这里统计所有逆序对，包括重复数字，例如: 3，2，2则包含两个逆序对(3, 2) (3, 2)
// 归并排序的时间复杂度为O(nlogn)
// 思路的重点在于分治法，归并过程中，mid两边是有序的，不存在逆序对，归并从最大端开始，利用有序避免遍历有序对
int merge_sort_part(int a[], int left, int right) {
    if (left >= right) {
        return 0;
    }

    int count = 0;
    int mid = (left + right) / 2;
    int count_left = merge_sort_part(a, left, mid);
    int count_right = merge_sort_part(a, mid + 1, right);
    count = merge(a, left, mid, right);

    return count + count_left + count_right;
}

int merge(int a[], int left, int mid, int right) {
    int i = mid;
    int j = right;
    int n = right - left + 1;
    int k = n - 1;
    int *array = new int[n];
    int count = 0;

    while (i >= 0 && j > mid) {
        if (a[i] > a[j]) {
            count = count + j - mid;
            array[k] = a[i];
            k--;
            i--;
        } else {
            array[k] = a[j];
            k--;
            j--;
        }
    }

    while (i >= 0) {
        array[k] = a[i];
        k--;
        i--;
    }

    while (j > mid) {
        array[k] = a[j];
        k--;
        j--;
    }

    for (i = 0; i < n; i++) {
        a[left++] = array[i];
    }

    delete [] array;
    return count;
}