算法08——归并排序

归并排序

$T(N)=2T(N/2)+O(N),a=2,b=2,d=1$
$lo{g}_b^a=d，故时间复杂度为O(N\ast logN)，空间复杂度为O(N)。$

public static void mergeSort(int[] arr){
	if (arr == null || arr.length < 2){
		return;
	}
	process(arr, 0, arr.length - 1);
}

public static void process(int[] arr, int L, int R){
	if (L == R){
		return;
	}
	int mid = L + ((R - L) >> 1);
	process(arr, 0, mid);
	process(arr, mid + 1, R);
	merge(arr, L, mid, R);
}

public static void merge(int[] arr, int L, int mid, int R){
	int[] help = new int[R - L + 1];
	int p1 = L;
	int p2 = mid + 1;
	int i = 0;
	while(p1 <= mid && p2 <= R){
		help[i++] = arr[p1] < arr[p2]? arr[p1++] : arr[p2++];
	}
	while(p1 <= mid){
		help[i++] = arr[p1++];
	}
	while(p2<=R){
		help[i++] = arr[p2++];
	}
	i = 0;
	for(; i < help.length; i++){
		arr[L + i] = help[i];
	}
}

归并排序相关算法

public static int countSmallSum(int[] arr){
        if (arr == null || arr.length <= 1){
            return 0;
        }
        return process(arr, 0, arr.length - 1);
    }
public static int process(int[] arr, int L, int R){
    if (L == R){
        return 0;
    }
    int mid = L + ((R - L) >> 1);
    return process(arr, L, mid) + process(arr, mid + 1, R) + merge(arr, L, mid, R);
}
public static int merge(int[] arr, int L, int mid, int R){
    int[] help = new int[R - L + 1];
    int p1 = L;
    int p2 = mid + 1;
    int i = 0;
    int res = 0;
    while(p1 <= mid && p2 <= R){
        if (arr[p1] < arr[p2]){
            res += arr[p1] * (R - p2 + 1);
            help[i++] = arr[p1++];
        }else{
            help[i++] = arr[p2++];
        }
    }
    while (p1 <= mid){
        help[i++] = arr[p1++];
    }
    while (p2 <= R){
        help[i++] = arr[p2++];
    }
    i = 0;
    for (; i < help.length; i++){
        arr[L + i] = help[i];
    }
    return res;
}

打印逆序对

public static void printReversePair(int[] arr){
    if (arr == null || arr.length < 2){
        return;
    }
    process(arr, 0, arr.length - 1);
}

public static void process(int[] arr, int L, int R){
    if (L == R){
        return;
    }
    int mid = L + ((R - L) >> 1);
    process(arr, L, mid);
    process(arr, mid + 1, R);
    merge(arr, L, mid, R);
    return;
}

public static void merge(int[] arr, int L, int mid, int R){
    int[] help = new int[R - L + 1];
    int p1 = L;
    int p2 = mid + 1;
    int i = 0;
    while (p1 <= mid && p2 <= R){
        if (arr[p1] > arr[p2]){
            for (int j = p1; j <= mid; j++){
                System.out.println("[" + arr[j] + ", " + arr[p2] + "]");
            }
        }
        help[i++] = arr[p1]< arr[p2]? arr[p1++] : arr[p2++];
    }
    while (p1 <=mid){
        help[i++] = arr[p1++];
    }
    while (p2 <= R){
        help[i++] = arr[p2++];
    }
    i = 0;
    for(; i < help.length; i++){
        arr[L + i] = help[i];
    }
    return;
}

计算逆序对数量

public static int countReversePair(int[] arr){
    if (arr == null || arr.length < 2){
        return 0;
    }
    return process(arr, 0, arr.length - 1);
}
public static int process(int[] arr, int L, int R){
    if (L == R){
        return 0;
    }
    int mid = L + ((R - L) >> 1);
    return process(arr, L, mid) + process(arr, mid + 1, R) + merge(arr, L, mid, R);
}
public static int merge(int[] arr, int L, int mid, int R){
    int[] help = new int[R - L + 1];
    int p1 = L;
    int p2 = mid + 1;
    int i = 0;
    int res = 0;
    while (p1 <= mid && p2 <= R){
        res += arr[p1] > arr[p2]? (mid - p1 + 1) : 0;
        help[i++] = arr[p1] < arr[p2]? arr[p1++] : arr[p2++];
    }
    while (p1 <= mid) {
        help[i++] = arr[p1++];
    }
    while (p2 <= R){
        help[i++] = arr[p2++];
    }
    i = 0;
    for(; i < help.length; i++){
        arr[L + i] = help[i];
    }
    return res;
}