modify code

src/class02/Code01_ReverseList.java

@@ -24,6 +24,9 @@ public class Code01_ReverseList {
 		}
 	}
 
+	//  head
+	//   a    ->   b    ->  c  ->  null
+	//   c    ->   b    ->  a  ->  null
 	public static Node reverseLinkedList(Node head) {
 		Node pre = null;
 		Node next = null;

src/class02/Code02_DeleteGivenValue.java

@@ -11,6 +11,7 @@ public class Code02_DeleteGivenValue {
 		}
 	}
 
+	// head = removeValue(head, 2);
 	public static Node removeValue(Node head, int num) {
 		// head来到第一个不需要删的位置
 		while (head != null) {
@@ -19,6 +20,8 @@ public class Code02_DeleteGivenValue {
 			}
 			head = head.next;
 		}
+		// 1 ) head == null
+		// 2 ) head != null
 		Node pre = head;
 		Node cur = head;
 		while (cur != null) {

src/class02/Code04_RingArray.java

@@ -4,8 +4,8 @@ public class Code04_RingArray {
 
 	public static class MyQueue {
 		private int[] arr;
-		private int pushi;
+		private int pushi;// end
-		private int polli;
+		private int polli;// begin
 		private int size;
 		private final int limit;
 
@@ -19,7 +19,7 @@ public class Code04_RingArray {
 
 		public void push(int value) {
 			if (size == limit) {
-				throw new RuntimeException("栈满了，不能再加了");
+				throw new RuntimeException("队列满了，不能再加了");
 			}
 			size++;
 			arr[pushi] = value;
@@ -28,7 +28,7 @@ public class Code04_RingArray {
 
 		public int pop() {
 			if (size == 0) {
-				throw new RuntimeException("栈空了，不能再拿了");
+				throw new RuntimeException("队列空了，不能再拿了");
 			}
 			size--;
 			int ans = arr[polli];

src/class02/Code08_GetMax.java

@@ -9,9 +9,12 @@ public class Code08_GetMax {
 
 	// arr[L..R]范围上求最大值  L ... R   N
 	public static int process(int[] arr, int L, int R) {
-		if (L == R) { // arr[L..R]范围上只有一个数，直接返回，base case
+		// arr[L..R]范围上只有一个数，直接返回，base case
+		if (L == R) { 
 			return arr[L];
 		}
+		// L...R 不只一个数
+		// mid = (L + R) / 2
 		int mid = L + ((R - L) >> 1); // 中点   	1
 		int leftMax = process(arr, L, mid);
 		int rightMax = process(arr, mid + 1, R);

src/class02/HashMapAndSortedMap.java

@@ -6,15 +6,38 @@ import java.util.TreeMap;
 
 public class HashMapAndSortedMap {
 
-	
+	public static class Node {
-	public static class Node{
 		public int value;
+
 		public Node(int v) {
-			 value = v;
+			value = v;
+		}
+	}
+
+	public static class Zuo {
+		public int value;
+
+		public Zuo(int v) {
+			value = v;
 		}
 	}
 
 	public static void main(String[] args) {
+
+		HashMap<Integer, String> test = new HashMap<>();
+		Integer a = 19000000;
+		Integer b = 19000000;
+		System.out.println(a == b);
+
+		test.put(a, "我是3");
+		System.out.println(test.containsKey(b));
+
+		Zuo z1 = new Zuo(1);
+		Zuo z2 = new Zuo(1);
+		HashMap<Zuo, String> test2 = new HashMap<>();
+		test2.put(z1, "我是z1");
+		System.out.println(test2.containsKey(z2));
+
 		// UnSortedMap
 		HashMap<Integer, String> map = new HashMap<>();
 		map.put(1000000, "我是1000000");
@@ -37,34 +60,24 @@ public class HashMapAndSortedMap {
 		map.remove(4);
 		System.out.println(map.get(4));
 
-		
+		// key
-		
+		HashSet<String> set = new HashSet<>();
-		//       key
-		HashSet<String>  set = new HashSet<>();
 		set.add("abc");
 		set.contains("abc");
 		set.remove("abc");
 
 		// 哈希表，增、删、改、查，在使用时，O（1）
 
-		
 		System.out.println("=====================");
 
-		
-		int a = 100000;
-		int b = 100000;
-		System.out.println(a == b);
-		
 		Integer c = 100000;
 		Integer d = 100000;
 		System.out.println(c.equals(d));
 
-		Integer e = 127;  //  - 128  ~  127
+		Integer e = 127; // - 128 ~ 127
 		Integer f = 127;
 		System.out.println(e == f);
 
-		
-		
 		HashMap<Node, String> map2 = new HashMap<>();
 		Node node1 = new Node(1);
 		Node node2 = node1;
@@ -74,6 +87,10 @@ public class HashMapAndSortedMap {
 
 		System.out.println("======================");
 
+		// TreeMap 有序表：接口名
+		// 红黑树、avl、sb树、跳表
+		// O(logN)
+		System.out.println("有序表测试开始");
 		TreeMap<Integer, String> treeMap = new TreeMap<>();
 
 		treeMap.put(3, "我是3");
@@ -93,20 +110,19 @@ public class HashMapAndSortedMap {
 		treeMap.put(4, "他是4");
 		System.out.println(treeMap.get(4));
 
-		treeMap.remove(4);
+		// treeMap.remove(4);
 		System.out.println(treeMap.get(4));
 
+		System.out.println("新鲜：");
+
 		System.out.println(treeMap.firstKey());
 		System.out.println(treeMap.lastKey());
 		// <= 4
 		System.out.println(treeMap.floorKey(4));
 		// >= 4
 		System.out.println(treeMap.ceilingKey(4));
-		
 		// O(logN)
 
 	}
 
-	
-	
 }

src/class03/Code03_ReversePair.java

@@ -0,0 +1,130 @@
+package class03;
+
+public class Code03_ReversePair {
+
+	public static int reverPairNumber(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return 0;
+		}
+		return process(arr, 0, arr.length - 1);
+	}
+
+	// arr[L..R]既要排好序，也要求逆序对数量返回
+	// 所有merge时，产生的逆序对数量，累加，返回
+	// 左 排序 merge并产生逆序对数量
+	// 右 排序 merge并产生逆序对数量
+	public static int process(int[] arr, int l, int r) {
+		if (l == r) {
+			return 0;
+		}
+		// l < r
+		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 m, int r) {
+		int[] help = new int[r - L + 1];
+		int i = help.length - 1;
+		int p1 = m;
+		int p2 = r;
+		int res = 0;
+		while (p1 >= L && p2 > m) {
+			res += arr[p1] > arr[p2] ? (p2 - m) : 0;
+			help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];
+		}
+		while (p1 >= L) {
+			help[i--] = arr[p1--];
+		}
+		while (p2 > m) {
+			help[i--] = arr[p2--];
+		}
+		for (i = 0; i < help.length; i++) {
+			arr[L + i] = help[i];
+		}
+		return res;
+	}
+
+	// for test
+	public static int comparator(int[] arr) {
+		int ans = 0;
+		for (int i = 0; i < arr.length; i++) {
+			for (int j = i + 1; j < arr.length; j++) {
+				if (arr[i] > arr[j]) {
+					ans++;
+				}
+			}
+		}
+		return ans;
+	}
+
+	// for test
+	public static int[] generateRandomArray(int maxSize, int maxValue) {
+		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
+		}
+		return arr;
+	}
+
+	// for test
+	public static int[] copyArray(int[] arr) {
+		if (arr == null) {
+			return null;
+		}
+		int[] res = new int[arr.length];
+		for (int i = 0; i < arr.length; i++) {
+			res[i] = arr[i];
+		}
+		return res;
+	}
+
+	// for test
+	public static boolean isEqual(int[] arr1, int[] arr2) {
+		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
+			return false;
+		}
+		if (arr1 == null && arr2 == null) {
+			return true;
+		}
+		if (arr1.length != arr2.length) {
+			return false;
+		}
+		for (int i = 0; i < arr1.length; i++) {
+			if (arr1[i] != arr2[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// for test
+	public static void printArray(int[] arr) {
+		if (arr == null) {
+			return;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	// for test
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 100;
+		int maxValue = 100;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			if (reverPairNumber(arr1) != comparator(arr2)) {
+				System.out.println("Oops!");
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class03/Code04_BiggerThanRightTwice.java

@@ -0,0 +1,132 @@
+package class03;
+
+public class Code04_BiggerThanRightTwice {
+
+	public static int biggerTwice(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;
+		}
+		// l < r
+		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 m, int r) {
+		int ans = 0;
+		int windowR = m + 1;
+		for (int i = L; i <= m; i++) {
+			while (windowR <= r && arr[i] > (arr[windowR] << 1)) {
+				windowR++;
+			}
+			ans += windowR - m - 1;
+		}
+		int[] help = new int[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;
+	}
+
+	// for test
+	public static int comparator(int[] arr) {
+		int ans = 0;
+		for (int i = 0; i < arr.length; i++) {
+			for (int j = i + 1; j < arr.length; j++) {
+				if (arr[i] > (arr[j] << 1)) {
+					ans++;
+				}
+			}
+		}
+		return ans;
+	}
+
+	// for test
+	public static int[] generateRandomArray(int maxSize, int maxValue) {
+		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
+		for (int i = 0; i < arr.length; i++) {
+			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) ((maxValue + 1) * Math.random());
+		}
+		return arr;
+	}
+
+	// for test
+	public static int[] copyArray(int[] arr) {
+		if (arr == null) {
+			return null;
+		}
+		int[] res = new int[arr.length];
+		for (int i = 0; i < arr.length; i++) {
+			res[i] = arr[i];
+		}
+		return res;
+	}
+
+	// for test
+	public static boolean isEqual(int[] arr1, int[] arr2) {
+		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
+			return false;
+		}
+		if (arr1 == null && arr2 == null) {
+			return true;
+		}
+		if (arr1.length != arr2.length) {
+			return false;
+		}
+		for (int i = 0; i < arr1.length; i++) {
+			if (arr1[i] != arr2[i]) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	// for test
+	public static void printArray(int[] arr) {
+		if (arr == null) {
+			return;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	// for test
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 100;
+		int maxValue = 100;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			if (biggerTwice(arr1) != comparator(arr2)) {
+				System.out.println("Oops!");
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class03/Code05_PartitionAndQuickSort.java

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

src/class03/Code06_QuickSortRecursiveAndUnrecursive.java

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