modify code

src/class03/Code01_MergeSort.java

@@ -2,8 +2,6 @@ package class03;
 
 public class Code01_MergeSort {
 
-
-
 	// 递归方法实现
 	public static void mergeSort1(int[] arr) {
 		if (arr == null || arr.length < 2) {
@@ -12,8 +10,10 @@ public class Code01_MergeSort {
 		process(arr, 0, arr.length - 1);
 	}
 
-	// arr[L...R]范围上，变成有序的
-	// L...R    N    T(N) = 2*T(N/2) + O(N)  ->
+	// 请把arr[L..R]排有序
+	// l...r  N
+	// T(N) = 2 * T(N / 2) + O(N)
+	// O(N * logN)
 	public static void process(int[] arr, int L, int R) {
 		if (L == R) { // base case
 			return;
@@ -50,21 +50,22 @@ public class Code01_MergeSort {
 			return;
 		}
 		int N = arr.length;
-		int mergeSize = 1;// 当前有序的，左组长度
+		// 步长
+		int mergeSize = 1;
 		while (mergeSize < N) { // log N
+			// 当前左组的，第一个位置
 			int L = 0;
-			// 0.... 
 			while (L < N) {
-				// L...M  左组（mergeSize）
 				int M = L + mergeSize - 1;
 				if (M >= N) {
 					break;
 				}
-				//  L...M   M+1...R(mergeSize)
 				int R = Math.min(M + mergeSize, N - 1);
+				// L .... M   M + 1..... R
 				merge(arr, L, M, R);
 				L = R + 1;
 			}
+			// 防止溢出
 			if (mergeSize > N / 2) {
 				break;
 			}

src/class03/Code04_BiggerThanRightTwice.java

@@ -19,14 +19,19 @@ public class Code04_BiggerThanRightTwice {
 	}
 
 	public static int merge(int[] arr, int L, int m, int r) {
+		// [L....M]   [M+1....R]
+		
 		int ans = 0;
+		// 目前囊括进来的数，是从[M+1, windowR)
 		int windowR = m + 1;
 		for (int i = L; i <= m; i++) {
-			while (windowR <= r && arr[i] > (arr[windowR] << 1)) {
+			while (windowR <= r && arr[i] > (arr[windowR] * 2)) {
 				windowR++;
 			}
 			ans += windowR - m - 1;
 		}
+		
+		
 		int[] help = new int[r - L + 1];
 		int i = 0;
 		int p1 = L;

src/class03/Code05_CountOfRangeSum.java

@@ -0,0 +1,62 @@
+package class03;
+
+// 这道题直接在leetcode测评：
+// https://leetcode.com/problems/count-of-range-sum/
+public class Code05_CountOfRangeSum {
+
+	public static int countRangeSum(int[] nums, int lower, int upper) {
+		if (nums == null || nums.length == 0) {
+			return 0;
+		}
+		long[] sum = new long[nums.length];
+		sum[0] = nums[0];
+		for (int i = 1; i < nums.length; i++) {
+			sum[i] = sum[i - 1] + nums[i];
+		}
+		return process(sum, 0, sum.length - 1, lower, upper);
+	}
+
+	public static int process(long[] sum, int L, int R, int lower, int upper) {
+		if (L == R) {
+			return sum[L] >= lower && sum[L] <= upper ? 1 : 0;
+		}
+		int M = L + ((R - L) >> 1);
+		return process(sum, L, M, lower, upper) + process(sum, M + 1, R, lower, upper)
+				+ merge(sum, L, M, R, lower, upper);
+	}
+
+	public static int merge(long[] arr, int L, int M, int R, int lower, int upper) {
+		int ans = 0;
+		int windowL = L;
+		int windowR = L;
+		for (int i = M + 1; i <= R; i++) {
+			long min = arr[i] - upper;
+			long max = arr[i] - lower;
+			while (windowR <= M && arr[windowR] <= max) {
+				windowR++;
+			}
+			while (windowL <= M && arr[windowL] < min) {
+				windowL++;
+			}
+			ans += Math.max(0, windowR - windowL);
+		}
+		long[] help = new long[R - L + 1];
+		int i = 0;
+		int p1 = L;
+		int p2 = M + 1;
+		while (p1 <= M && p2 <= R) {
+			help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
+		}
+		while (p1 <= M) {
+			help[i++] = arr[p1++];
+		}
+		while (p2 <= R) {
+			help[i++] = arr[p2++];
+		}
+		for (i = 0; i < help.length; i++) {
+			arr[L + i] = help[i];
+		}
+		return ans;
+	}
+
+}

src/class03/Code06_PartitionAndQuickSort.java

@@ -1,6 +1,6 @@
 package class03;
 
-public class Code05_PartitionAndQuickSort {
+public class Code06_PartitionAndQuickSort {
 
 	public static void swap(int[] arr, int i, int j) {
 		int tmp = arr[i];

src/class03/Code07_QuickSortRecursiveAndUnrecursive.java

@@ -2,7 +2,7 @@ package class03;
 
 import java.util.Stack;
 
-public class Code06_QuickSortRecursiveAndUnrecursive {
+public class Code07_QuickSortRecursiveAndUnrecursive {
 
 	// 荷兰国旗问题
 	public static int[] netherlandsFlag(int[] arr, int L, int R) {