Initial commit

.gitignore

@@ -0,0 +1,2 @@
+# 项目排除路径
+/out/

.idea/.gitignore

@@ -0,0 +1,8 @@
+# 默认忽略的文件
+/shelf/
+/workspace.xml
+# 基于编辑器的 HTTP 客户端请求
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/libraries/Java_EE_6_Java_EE_6.xml

@@ -0,0 +1,17 @@
+<component name="libraryTable">
+  <library name="Java EE 6-Java EE 6">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/lib/javax.transaction.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.annotation.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.servlet.jsp.jstl.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.jms.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.resource.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.servlet.jsp.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.servlet.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.ejb.jar!/" />
+      <root url="jar://$PROJECT_DIR$/lib/javax.persistence.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/AlgorithmZuo.iml" filepath="$PROJECT_DIR$/AlgorithmZuo.iml" />
+    </modules>
+  </component>
+</project>

AlgorithmZuo.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Java EE 6-Java EE 6" level="project" />
+  </component>
+</module>

src/class01/Code01_SelectionSort.java

@@ -0,0 +1,115 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code01_SelectionSort {
+
+	public static void selectionSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		// 0 ~ N-1  找到最小值，在哪，放到0位置上
+		// 1 ~ n-1  找到最小值，在哪，放到1 位置上
+		// 2 ~ n-1  找到最小值，在哪，放到2 位置上
+		for (int i = 0; i < arr.length - 1; i++) {
+			int minIndex = i;
+			for (int j = i + 1; j < arr.length; j++) { // i ~ N-1 上找最小值的下标 
+				minIndex = arr[j] < arr[minIndex] ? j : minIndex;
+			}
+			swap(arr, i, minIndex);
+		}
+	}
+
+	public static void swap(int[] arr, int i, int j) {
+		int tmp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = tmp;
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// for test
+	public static int[] generateRandomArray(int maxSize, int maxValue) {
+		// Math.random()   [0,1)  
+		// Math.random() * N  [0,N)
+		// (int)(Math.random() * N)  [0, N-1]
+		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;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			selectionSort(arr1);
+			comparator(arr2);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		selectionSort(arr);
+		printArray(arr);
+	}
+
+}

src/class01/Code02_BubbleSort.java

@@ -0,0 +1,110 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code02_BubbleSort {
+
+	public static void bubbleSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		// 0 ~ N-1
+		// 0 ~ N-2
+		// 0 ~ N-3
+		for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
+			for (int i = 0; i < e; i++) {
+				if (arr[i] > arr[i + 1]) {
+					swap(arr, i, i + 1);
+				}
+			}
+		}
+	}
+
+	// 交换arr的i和j位置上的值
+	public static void swap(int[] arr, int i, int j) {
+		arr[i] = arr[i] ^ arr[j];
+		arr[j] = arr[i] ^ arr[j];
+		arr[i] = arr[i] ^ arr[j];
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// 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;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			bubbleSort(arr1);
+			comparator(arr2);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		bubbleSort(arr);
+		printArray(arr);
+	}
+
+}

src/class01/Code03_InsertionSort.java

@@ -0,0 +1,130 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code03_InsertionSort {
+
+	public static void insertionSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		// 不只1个数
+		for (int i = 1; i < arr.length; i++) { // 0 ~ i 做到有序
+			for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
+				swap(arr, j, j + 1);
+			}
+		}
+	}
+
+	public static void insertionSort_02(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		int p,i;
+		for (p=1;p<arr.length;p++){
+			int temp = arr[p];
+			for (i=p;i>0&&temp<arr[i-1];i--){
+				arr[i]=arr[i-1];
+			}
+			arr[i]=temp;
+		}
+	}
+
+	// i和j是一个位置的话，会出错
+	public static void swap(int[] arr, int i, int j) {
+		arr[i] = arr[i] ^ arr[j];
+		arr[j] = arr[i] ^ arr[j];
+		arr[i] = arr[i] ^ arr[j];
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// for test
+	public static int[] generateRandomArray(int maxSize, int maxValue) {
+		// Math.random() -> [0,1) 所有的小数，等概率返回一个
+		// Math.random() * N -> [0,N) 所有小数，等概率返回一个
+		// (int)(Math.random() * N) -> [0,N-1] 所有的整数，等概率返回一个
+		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; // 随机数组的长度0～100
+		int maxValue = 100;// 值：-100～100
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+			int[] arr1 = copyArray(arr);
+			int[] arr2 = copyArray(arr);
+			insertionSort(arr1);
+			comparator(arr2);//利用java内部的排序算法保证一定对
+			if (!isEqual(arr1, arr2)) {
+				// 打印arr1
+				// 打印arr2
+				succeed = false;
+				for (int j = 0; j < arr.length; j++) {
+					System.out.print(arr[j] + " ");
+				}
+				System.out.println();
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		insertionSort_02(arr);
+		printArray(arr);
+	}
+
+}

src/class01/Code04_BSExist.java

@@ -0,0 +1,65 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code04_BSExist {
+
+	public static boolean exist(int[] sortedArr, int num) {
+		if (sortedArr == null || sortedArr.length == 0) {
+			return false;
+		}
+		int L = 0;
+		int R = sortedArr.length - 1;
+		int mid = 0;
+		// L..R
+		while (L < R) { // L..R 至少两个数的时候
+			mid = L + ((R - L) >> 1);
+			if (sortedArr[mid] == num) {
+				return true;
+			} else if (sortedArr[mid] > num) {
+				R = mid - 1;
+			} else {
+				L = mid + 1;
+			}
+		}
+		return sortedArr[L] == num;
+	}
+	
+	// for test
+	public static boolean test(int[] sortedArr, int num) {
+		for(int cur : sortedArr) {
+			if(cur == num) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	
+	// 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;
+	}
+	
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 10;
+		int maxValue = 100;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+			Arrays.sort(arr);
+			int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
+			if (test(arr, value) != exist(arr, value)) {
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+	}
+
+}

src/class01/Code05_BSNearLeft.java

@@ -0,0 +1,75 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code05_BSNearLeft {
+
+	// 在arr上，找满足>=value的最左位置
+	public static int nearestIndex(int[] arr, int value) {
+		int L = 0;
+		int R = arr.length - 1;
+		int index = -1; // 记录最左的对号
+		while (L <= R) { // 至少一个数的时候
+			int mid = L + ((R - L) >> 1);
+			if (arr[mid] >= value) {
+				index = mid;
+				R = mid - 1;
+			} else {
+				L = mid + 1;
+			}
+		}
+		return index;
+	}
+
+	// for test
+	public static int test(int[] arr, int value) {
+		for (int i = 0; i < arr.length; i++) {
+			if (arr[i] >= value) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	// 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 void printArray(int[] arr) {
+		if (arr == null) {
+			return;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 10;
+		int maxValue = 100;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+			Arrays.sort(arr);
+			int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
+			if (test(arr, value) != nearestIndex(arr, value)) {
+				printArray(arr);
+				System.out.println(value);
+				System.out.println(test(arr, value));
+				System.out.println(nearestIndex(arr, value));
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+	}
+
+}

src/class01/Code05_BSNearRight.java

@@ -0,0 +1,75 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code05_BSNearRight {
+
+	// 在arr上，找满足<=value的最右位置
+	public static int nearestIndex(int[] arr, int value) {
+		int L = 0;
+		int R = arr.length - 1;
+		int index = -1; // 记录最右的对号
+		while (L <= R) {
+			int mid = L + ((R - L) >> 1);
+			if (arr[mid] <= value) {
+				index = mid;
+				L = mid + 1;
+			} else {
+				R = mid - 1;
+			}
+		}
+		return index;
+	}
+
+	// for test
+	public static int test(int[] arr, int value) {
+		for (int i = arr.length - 1; i >= 0; i--) {
+			if (arr[i] <= value) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	// 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 void printArray(int[] arr) {
+		if (arr == null) {
+			return;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 10;
+		int maxValue = 100;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+			Arrays.sort(arr);
+			int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
+			if (test(arr, value) != nearestIndex(arr, value)) {
+				printArray(arr);
+				System.out.println(value);
+				System.out.println(test(arr, value));
+				System.out.println(nearestIndex(arr, value));
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+	}
+
+}

src/class01/Code06_BSAwesome.java

@@ -0,0 +1,79 @@
+package class01;
+
+import java.util.Arrays;
+
+public class Code06_BSAwesome {
+
+	// 课上的代码
+	public static int getLessIndex(int[] arr) {
+		if (arr == null || arr.length == 0) {
+			return -1;
+		}
+		if (arr.length == 1 || arr[0] < arr[1]) {
+			return 0;
+		}
+		if (arr[arr.length - 1] < arr[arr.length - 2]) {
+			return arr.length - 1;
+		}
+		int left = 1;
+		int right = arr.length - 2;
+		int mid = 0;
+		while (left < right) {
+			mid = (left + right) / 2;
+			if (arr[mid] > arr[mid - 1]) {
+				right = mid - 1;
+			} else if (arr[mid] > arr[mid + 1]) {
+				left = mid + 1;
+			} else {
+				return mid;
+			}
+		}
+		return left;
+	}
+
+	// 验证得到的结果，是不是局部最小
+	public static boolean isRight(int[] arr, int index) {
+		if (arr.length <= 1) {
+			return true;
+		}
+		if (index == 0) {
+			return arr[index] < arr[index + 1];
+		}
+		if (index == arr.length - 1) {
+			return arr[index] < arr[index - 1];
+		}
+		return arr[index] < arr[index - 1] && arr[index] < arr[index + 1];
+	}
+
+	// 为了测试
+	// 生成相邻不相等的数组
+	public static int[] generateRandomArray(int maxSize, int maxValue) {
+		int[] arr = new int[(int) (Math.random() * maxSize) + 1];
+		arr[0] = (int) (Math.random() * maxValue) - (int) (Math.random() * maxValue);
+		for (int i = 1; i < arr.length; i++) {
+			do {
+				arr[i] = (int) (Math.random() * maxValue) - (int) (Math.random() * maxValue);
+			} while (arr[i] == arr[i - 1]);
+		}
+		return arr;
+	}
+
+	// 为了测试
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 30;
+		int maxValue = 100;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+//			Arrays.sort(arr);
+			int ans = getLessIndex(arr);
+			if (!isRight(arr, ans)) {
+				System.out.println("出错了！");
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class01/Code07_EvenTimesOddTimes.java

@@ -0,0 +1,35 @@
+package class01;
+
+public class Code07_EvenTimesOddTimes {
+    public static void printOddTimesOneNumber(int[] arr){
+        int eor=0;
+        for(int i:arr)  eor^=i;//出来之后eor就是我们要的
+        System.out.println(eor);
+    }
+
+    public static void printOddTimesTwoNumber(int[] arr){
+        int eor=0;
+        for(int i:arr)  eor^=i;//出来之后eor=a^b
+        /**
+         * 我们异或了所有的数得到了eor=a^b，现在要分别得到a和b还缺少一个条件。
+         * 一个思路就是不去异或所有的数，我们只异或一部分的数，并且这一部分只包含 a和b的其中一个
+         * 方法是找出a与b不同的那一位，利用掩码将a和b划分成两个子集，每个子集异或进去可以达到a或者是b。
+         * 问题关键来到如何找出a和b不同的那一位，事实上a^b为1的那些位都是a和b不同的位，这里我们找a^b最右边的1
+         * 小结论：一个数和它的补码的与运算得到的就是最右边的那一位---想想补码是怎么求的
+         */
+        int mask=eor&(~eor+1);//得到了掩码
+        int aORb=0,another=0 ;
+        for(int i:arr)  {
+            if((i&mask)==mask) aORb^=i;//该位置为1的全部异或起来
+        }
+        another=eor^aORb;
+        System.out.println(another+" "+aORb);
+    }
+
+    public static void main(String[] args) {
+        int [] arr1={1,1,1,6,6,2,2};
+        int [] arr2={1,1,1,6,6,6,2,2};
+        printOddTimesOneNumber(arr1);
+        printOddTimesTwoNumber(arr2);
+    }
+}

src/class01/Code08_GetMax.java

@@ -0,0 +1,19 @@
+package class01;
+
+public class Code08_GetMax {
+
+	public static int getMax(int[] arr) {
+		return process(arr, 0, arr.length - 1);
+	}
+
+	public static int process(int[] arr, int L, int R) {
+		if (L == R) {
+			return arr[L];
+		}
+		int mid = L + ((R - L) >> 1);
+		int leftMax = process(arr, L, mid);
+		int rightMax = process(arr, mid + 1, R);
+		return Math.max(leftMax, rightMax);
+	}
+
+}

src/class01/Code09_FindOneLessValueIndex.java

@@ -0,0 +1,46 @@
+package class01;
+
+public class Code09_FindOneLessValueIndex {
+
+	public static int getLessIndex(int[] arr) {
+		if (arr == null || arr.length == 0) {
+			return -1; // no exist
+		}
+		if (arr.length == 1 || arr[0] < arr[1]) {
+			return 0;
+		}
+		if (arr[arr.length - 1] < arr[arr.length - 2]) {
+			return arr.length - 1;
+		}
+		int left = 1;
+		int right = arr.length - 2;
+		int mid = 0;
+		while (left < right) {
+			mid = (left + right) / 2;
+			if (arr[mid] > arr[mid - 1]) {
+				right = mid - 1;
+			} else if (arr[mid] > arr[mid + 1]) {
+				left = mid + 1;
+			} else {
+				return mid;
+			}
+		}
+		return left;
+	}
+
+	public static void printArray(int[] arr) {
+		for (int i = 0; i != arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		int[] arr = { 6, 5, 3, 4, 6, 7, 8 };
+		printArray(arr);
+		int index = getLessIndex(arr);
+		System.out.println("index: " + index + ", value: " + arr[index]);
+
+	}
+
+}

src/class02/Code01_Swap.java

@@ -0,0 +1,71 @@
+package class02;
+
+public class Code01_Swap {
+	
+	public static void main(String[] args) {
+
+		
+		
+		
+		
+		
+		int a = 16;
+		int b = 603;
+		
+		System.out.println(a);
+		System.out.println(b);
+		
+		
+		a = a ^ b;
+		b = a ^ b;
+		a = a ^ b;
+		
+		
+		System.out.println(a);
+		System.out.println(b);
+		
+		
+		
+		
+		int[] arr = {3,1,100};
+		
+		int i = 0;
+		int j = 0;
+		
+		arr[i] = arr[i] ^ arr[j];
+		arr[j] = arr[i] ^ arr[j];
+		arr[i] = arr[i] ^ arr[j];
+		
+		System.out.println(arr[i] + " , " + arr[j]);
+		
+		
+		
+		
+		
+		
+		
+		
+		
+		System.out.println(arr[0]);
+		System.out.println(arr[2]);
+		
+		swap(arr, 0, 0);
+		
+		System.out.println(arr[0]);
+		System.out.println(arr[2]);
+		
+		
+		
+	}
+	
+	
+	public static void swap (int[] arr, int i, int j) {
+		// arr[0] = arr[0] ^ arr[0];
+		arr[i]  = arr[i] ^ arr[j];
+		arr[j]  = arr[i] ^ arr[j];
+		arr[i]  = arr[i] ^ arr[j];
+	}
+	
+	
+
+}

src/class02/Code02_EvenTimesOddTimes.java

@@ -0,0 +1,83 @@
+package class02;
+
+public class Code02_EvenTimesOddTimes {
+
+	// arr中，只有一种数，出现奇数次
+	public static void printOddTimesNum1(int[] arr) {
+		int eor = 0;
+		for (int i = 0; i < arr.length; i++) {
+			eor ^= arr[i];
+		}
+		System.out.println(eor);
+	}
+
+	// arr中，有两种数，出现奇数次
+	public static void printOddTimesNum2(int[] arr) {
+		int eor = 0;
+		for (int i = 0; i < arr.length; i++) {
+			eor ^= arr[i];
+		}
+		// a 和 b是两种数
+		// eor != 0
+		// eor最右侧的1，提取出来
+		// eor :     00110010110111000
+		// rightOne :00000000000001000
+		int rightOne = eor & (-eor); // 提取出最右的1
+		
+		
+		int onlyOne = 0; // eor'
+		for (int i = 0 ; i < arr.length;i++) {
+			//  arr[1] =  111100011110000
+			// rightOne=  000000000010000
+			if ((arr[i] & rightOne) != 0) {
+				onlyOne ^= arr[i];
+			}
+		}
+		System.out.println(onlyOne + " " + (eor ^ onlyOne));
+	}
+
+	
+	public static int bit1counts(int N) {
+		int count = 0;
+		
+		//   011011010000
+		//   000000010000     1
+		
+		//   011011000000
+		// 
+		
+		
+		
+		while(N != 0) {
+			int rightOne = N & ((~N) + 1);
+			count++;
+			N ^= rightOne;
+			// N -= rightOne
+		}
+		
+		
+		return count;
+		
+	}
+	
+	
+	public static void main(String[] args) {
+		int a = 5;
+		int b = 7;
+
+		a = a ^ b;
+		b = a ^ b;
+		a = a ^ b;
+
+		System.out.println(a);
+		System.out.println(b);
+
+		int[] arr1 = { 3, 3, 2, 3, 1, 1, 1, 3, 1, 1, 1 };
+		printOddTimesNum1(arr1);
+
+		int[] arr2 = { 4, 3, 4, 2, 2, 2, 4, 1, 1, 1, 3, 3, 1, 1, 1, 4, 2, 2 };
+		printOddTimesNum2(arr2);
+
+	}
+
+}

src/class02/Code03_KM.java

@@ -0,0 +1,159 @@
+package class02;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+// 输入一定能够保证，数组中所有的数都出现了M次，只有一种数出现了K次
+// 1 <= K < M
+// 返回这种数
+public class Code03_KM {
+
+	public static int test(int[] arr, int k, int m) {
+		HashMap<Integer, Integer> map = new HashMap<>();
+		for (int num : arr) {
+			if (map.containsKey(num)) {
+				map.put(num, map.get(num) + 1);
+			} else {
+				map.put(num, 1);
+			}
+		}
+		int ans = 0;
+		for (int num : map.keySet()) {
+			if (map.get(num) == k) {
+				ans = num;
+				break;
+			}
+		}
+		return ans;
+	}
+
+	public static HashMap<Integer, Integer> map = new HashMap<>();
+
+	// 请保证arr中，只有一种数出现了K次，其他数都出现了M次
+	public static int onlyKTimes(int[] arr, int k, int m) {
+		if (map.size() == 0) {
+			mapCreater(map);
+		}
+		int[] t = new int[32];
+		// t[0] 0位置的1出现了几个
+		// t[i] i位置的1出现了几个
+		for (int num : arr) {
+			while (num != 0) {
+				int rightOne = num & (-num);
+				t[map.get(rightOne)]++;
+				num ^= rightOne;
+			}
+		}
+		int ans = 0;
+		// 如果这个出现了K次的数，就是0
+		// 那么下面代码中的 : ans |= (1 << i);
+		// 就不会发生
+		// 那么ans就会一直维持0，最后返回0，也是对的！
+		for (int i = 0; i < 32; i++) {
+			if (t[i] % m != 0) {
+				ans |= (1 << i);
+			}
+		}
+		return ans;
+	}
+
+	public static void mapCreater(HashMap<Integer, Integer> map) {
+		int value = 1;
+		for (int i = 0; i < 32; i++) {
+			map.put(value, i);
+			value <<= 1;
+		}
+	}
+
+	// 更简洁的写法
+	public static int km(int[] arr, int k, int m) {
+		int[] help = new int[32];
+		for (int num : arr) {
+			for (int i = 0; i < 32; i++) {
+				help[i] += (num >> i) & 1;
+			}
+		}
+		int ans = 0;
+		for (int i = 0; i < 32; i++) {
+			help[i] %= m;
+			if (help[i] != 0) {
+				ans |= 1 << i;
+			}
+		}
+		return ans;
+	}
+
+	// 为了测试
+	public static int[] randomArray(int maxKinds, int range, int k, int m) {
+		int ktimeNum = randomNumber(range);
+		// 真命天子出现的次数
+		int times = k;
+		// 2
+		int numKinds = (int) (Math.random() * maxKinds) + 2;
+		// k * 1 + (numKinds - 1) * m
+		int[] arr = new int[times + (numKinds - 1) * m];
+		int index = 0;
+		for (; index < times; index++) {
+			arr[index] = ktimeNum;
+		}
+		numKinds--;
+		HashSet<Integer> set = new HashSet<>();
+		set.add(ktimeNum);
+		while (numKinds != 0) {
+			int curNum = 0;
+			do {
+				curNum = randomNumber(range);
+			} while (set.contains(curNum));
+			set.add(curNum);
+			numKinds--;
+			for (int i = 0; i < m; i++) {
+				arr[index++] = curNum;
+			}
+		}
+		// arr 填好了
+		for (int i = 0; i < arr.length; i++) {
+			// i 位置的数，我想随机和j位置的数做交换
+			int j = (int) (Math.random() * arr.length);// 0 ~ N-1
+			int tmp = arr[i];
+			arr[i] = arr[j];
+			arr[j] = tmp;
+		}
+		return arr;
+	}
+
+	// 为了测试
+	// [-range, +range]
+	public static int randomNumber(int range) {
+		return (int) (Math.random() * (range + 1)) - (int) (Math.random() * (range + 1));
+	}
+
+	// 为了测试
+	public static void main(String[] args) {
+		int kinds = 5;
+		int range = 30;
+		int testTime = 100000;
+		int max = 9;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTime; i++) {
+			int a = (int) (Math.random() * max) + 1; // a 1 ~ 9
+			int b = (int) (Math.random() * max) + 1; // b 1 ~ 9
+			int k = Math.min(a, b);
+			int m = Math.max(a, b);
+			// k < m
+			if (k == m) {
+				m++;
+			}
+			int[] arr = randomArray(kinds, range, k, m);
+			int ans1 = test(arr, k, m);
+			int ans2 = onlyKTimes(arr, k, m);
+			int ans3 = km(arr, k, m);
+			if (ans1 != ans2 || ans1 != ans3) {
+				System.out.println(ans1);
+				System.out.println(ans3);
+				System.out.println("出错了！");
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class03/Code01_ReverseList.java

@@ -0,0 +1,221 @@
+package class03;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Code01_ReverseList {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			value = data;
+		}
+	}
+
+	public static class DoubleNode {
+		public int value;
+		public DoubleNode last;
+		public DoubleNode next;
+
+		public DoubleNode(int data) {
+			value = data;
+		}
+	}
+
+	//  head
+	//   a    ->   b    ->  c  ->  null
+	//   c    ->   b    ->  a  ->  null
+	public static Node reverseLinkedList(Node head) {
+		Node pre = null;
+		Node next = null;
+		while (head != null) {
+			next = head.next;
+			head.next = pre;
+			pre = head;
+			head = next;
+		}
+		return pre;
+	}
+
+	public static DoubleNode reverseDoubleList(DoubleNode head) {
+		DoubleNode pre = null;
+		DoubleNode next = null;
+		while (head != null) {
+			next = head.next;
+			head.next = pre;
+			head.last = next;
+			pre = head;
+			head = next;
+		}
+		return pre;
+	}
+
+	public static Node testReverseLinkedList(Node head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<Node> list = new ArrayList<>();
+		while (head != null) {
+			list.add(head);
+			head = head.next;
+		}
+		list.get(0).next = null;
+		int N = list.size();
+		for (int i = 1; i < N; i++) {
+			list.get(i).next = list.get(i - 1);
+		}
+		return list.get(N - 1);
+	}
+
+	public static DoubleNode testReverseDoubleList(DoubleNode head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<DoubleNode> list = new ArrayList<>();
+		while (head != null) {
+			list.add(head);
+			head = head.next;
+		}
+		list.get(0).next = null;
+		DoubleNode pre = list.get(0);
+		int N = list.size();
+		for (int i = 1; i < N; i++) {
+			DoubleNode cur = list.get(i);
+			cur.last = null;
+			cur.next = pre;
+			pre.last = cur;
+			pre = cur;
+		}
+		return list.get(N - 1);
+	}
+
+	// for test
+	public static Node generateRandomLinkedList(int len, int value) {
+		int size = (int) (Math.random() * (len + 1));
+		if (size == 0) {
+			return null;
+		}
+		size--;
+		Node head = new Node((int) (Math.random() * (value + 1)));
+		Node pre = head;
+		while (size != 0) {
+			Node cur = new Node((int) (Math.random() * (value + 1)));
+			pre.next = cur;
+			pre = cur;
+			size--;
+		}
+		return head;
+	}
+
+	// for test
+	public static DoubleNode generateRandomDoubleList(int len, int value) {
+		int size = (int) (Math.random() * (len + 1));
+		if (size == 0) {
+			return null;
+		}
+		size--;
+		DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
+		DoubleNode pre = head;
+		while (size != 0) {
+			DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
+			pre.next = cur;
+			cur.last = pre;
+			pre = cur;
+			size--;
+		}
+		return head;
+	}
+
+	// for test
+	public static List<Integer> getLinkedListOriginOrder(Node head) {
+		List<Integer> ans = new ArrayList<>();
+		while (head != null) {
+			ans.add(head.value);
+			head = head.next;
+		}
+		return ans;
+	}
+
+	// for test
+	public static boolean checkLinkedListReverse(List<Integer> origin, Node head) {
+		for (int i = origin.size() - 1; i >= 0; i--) {
+			if (!origin.get(i).equals(head.value)) {
+				return false;
+			}
+			head = head.next;
+		}
+		return true;
+	}
+
+	// for test
+	public static List<Integer> getDoubleListOriginOrder(DoubleNode head) {
+		List<Integer> ans = new ArrayList<>();
+		while (head != null) {
+			ans.add(head.value);
+			head = head.next;
+		}
+		return ans;
+	}
+
+	// for test
+	public static boolean checkDoubleListReverse(List<Integer> origin, DoubleNode head) {
+		DoubleNode end = null;
+		for (int i = origin.size() - 1; i >= 0; i--) {
+			if (!origin.get(i).equals(head.value)) {
+				return false;
+			}
+			end = head;
+			head = head.next;
+		}
+		for (int i = 0; i < origin.size(); i++) {
+			if (!origin.get(i).equals(end.value)) {
+				return false;
+			}
+			end = end.last;
+		}
+		return true;
+	}
+
+	// for test
+	public static void main(String[] args) {
+		int len = 50;
+		int value = 100;
+		int testTime = 100000;
+		System.out.println("test begin!");
+		for (int i = 0; i < testTime; i++) {
+			Node node1 = generateRandomLinkedList(len, value);
+			List<Integer> list1 = getLinkedListOriginOrder(node1);
+			node1 = reverseLinkedList(node1);
+			if (!checkLinkedListReverse(list1, node1)) {
+				System.out.println("Oops1!");
+			}
+
+			Node node2 = generateRandomLinkedList(len, value);
+			List<Integer> list2 = getLinkedListOriginOrder(node2);
+			node2 = testReverseLinkedList(node2);
+			if (!checkLinkedListReverse(list2, node2)) {
+				System.out.println("Oops2!");
+			}
+
+			DoubleNode node3 = generateRandomDoubleList(len, value);
+			List<Integer> list3 = getDoubleListOriginOrder(node3);
+			node3 = reverseDoubleList(node3);
+			if (!checkDoubleListReverse(list3, node3)) {
+				System.out.println("Oops3!");
+			}
+
+			DoubleNode node4 = generateRandomDoubleList(len, value);
+			List<Integer> list4 = getDoubleListOriginOrder(node4);
+			node4 = reverseDoubleList(node4);
+			if (!checkDoubleListReverse(list4, node4)) {
+				System.out.println("Oops4!");
+			}
+
+		}
+		System.out.println("test finish!");
+
+	}
+
+}

src/class03/Code02_DeleteGivenValue.java

@@ -0,0 +1,38 @@
+package class03;
+
+public class Code02_DeleteGivenValue {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	// head = removeValue(head, 2);
+	public static Node removeValue(Node head, int num) {
+		// head来到第一个不需要删的位置
+		while (head != null) {
+			if (head.value != num) {
+				break;
+			}
+			head = head.next;
+		}
+		// 1 ) head == null
+		// 2 ) head != null
+		Node pre = head;
+		Node cur = head;
+		while (cur != null) {
+			if (cur.value == num) {
+				pre.next = cur.next;
+			} else {
+				pre = cur;
+			}
+			cur = cur.next;
+		}
+		return head;
+	}
+
+}

src/class03/Code03_DoubleEndsQueueToStackAndQueue.java

@@ -0,0 +1,183 @@
+package class03;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class Code03_DoubleEndsQueueToStackAndQueue {
+
+	public static class Node<T> {
+		public T value;
+		public Node<T> last;
+		public Node<T> next;
+
+		public Node(T data) {
+			value = data;
+		}
+	}
+
+	public static class DoubleEndsQueue<T> {
+		public Node<T> head;
+		public Node<T> tail;
+
+		public void addFromHead(T value) {
+			Node<T> cur = new Node<T>(value);
+			if (head == null) {
+				head = cur;
+				tail = cur;
+			} else {
+				cur.next = head;
+				head.last = cur;
+				head = cur;
+			}
+		}
+
+		public void addFromBottom(T value) {
+			Node<T> cur = new Node<T>(value);
+			if (head == null) {
+				head = cur;
+				tail = cur;
+			} else {
+				cur.last = tail;
+				tail.next = cur;
+				tail = cur;
+			}
+		}
+
+		public T popFromHead() {
+			if (head == null) {
+				return null;
+			}
+			Node<T> cur = head;
+			if (head == tail) {
+				head = null;
+				tail = null;
+			} else {
+				head = head.next;
+				cur.next = null;
+				head.last = null;
+			}
+			return cur.value;
+		}
+
+		public T popFromBottom() {
+			if (head == null) {
+				return null;
+			}
+			Node<T> cur = tail;
+			if (head == tail) {
+				head = null;
+				tail = null;
+			} else {
+				tail = tail.last;
+				tail.next = null;
+				cur.last = null;
+			}
+			return cur.value;
+		}
+
+		public boolean isEmpty() {
+			return head == null;
+		}
+
+	}
+
+	public static class MyStack<T> {
+		private DoubleEndsQueue<T> queue;
+
+		public MyStack() {
+			queue = new DoubleEndsQueue<T>();
+		}
+
+		public void push(T value) {
+			queue.addFromHead(value);
+		}
+
+		public T pop() {
+			return queue.popFromHead();
+		}
+
+		public boolean isEmpty() {
+			return queue.isEmpty();
+		}
+
+	}
+
+	public static class MyQueue<T> {
+		private DoubleEndsQueue<T> queue;
+
+		public MyQueue() {
+			queue = new DoubleEndsQueue<T>();
+		}
+
+		public void push(T value) {
+			queue.addFromHead(value);
+		}
+
+		public T poll() {
+			return queue.popFromBottom();
+		}
+
+		public boolean isEmpty() {
+			return queue.isEmpty();
+		}
+
+	}
+
+	public static boolean isEqual(Integer o1, Integer o2) {
+		if (o1 == null && o2 != null) {
+			return false;
+		}
+		if (o1 != null && o2 == null) {
+			return false;
+		}
+		if (o1 == null && o2 == null) {
+			return true;
+		}
+		return o1.equals(o2);
+	}
+
+	public static void main(String[] args) {
+		int oneTestDataNum = 100;
+		int value = 10000;
+		int testTimes = 100000;
+		for (int i = 0; i < testTimes; i++) {
+			MyStack<Integer> myStack = new MyStack<>();
+			MyQueue<Integer> myQueue = new MyQueue<>();
+			Stack<Integer> stack = new Stack<>();
+			Queue<Integer> queue = new LinkedList<>();
+			for (int j = 0; j < oneTestDataNum; j++) {
+				int nums = (int) (Math.random() * value);
+				if (stack.isEmpty()) {
+					myStack.push(nums);
+					stack.push(nums);
+				} else {
+					if (Math.random() < 0.5) {
+						myStack.push(nums);
+						stack.push(nums);
+					} else {
+						if (!isEqual(myStack.pop(), stack.pop())) {
+							System.out.println("oops!");
+						}
+					}
+				}
+				int numq = (int) (Math.random() * value);
+				if (queue.isEmpty()) {
+					myQueue.push(numq);
+					queue.offer(numq);
+				} else {
+					if (Math.random() < 0.5) {
+						myQueue.push(numq);
+						queue.offer(numq);
+					} else {
+						if (!isEqual(myQueue.poll(), queue.poll())) {
+							System.out.println("oops!");
+						}
+					}
+				}
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class03/Code04_RingArray.java

@@ -0,0 +1,50 @@
+package class03;
+
+public class Code04_RingArray {
+
+	public static class MyQueue {
+		private int[] arr;
+		private int pushi;// end
+		private int polli;// begin
+		private int size;
+		private final int limit;
+
+		public MyQueue(int limit) {
+			arr = new int[limit];
+			pushi = 0;
+			polli = 0;
+			size = 0;
+			this.limit = limit;
+		}
+
+		public void push(int value) {
+			if (size == limit) {
+				throw new RuntimeException("队列满了，不能再加了");
+			}
+			size++;
+			arr[pushi] = value;
+			pushi = nextIndex(pushi);
+		}
+
+		public int pop() {
+			if (size == 0) {
+				throw new RuntimeException("队列空了，不能再拿了");
+			}
+			size--;
+			int ans = arr[polli];
+			polli = nextIndex(polli);
+			return ans;
+		}
+
+		public boolean isEmpty() {
+			return size == 0;
+		}
+
+		// 如果现在的下标是i，返回下一个位置
+		private int nextIndex(int i) {
+			return i < limit - 1 ? i + 1 : 0;
+		}
+
+	}
+
+}

src/class03/Code05_GetMinStack.java

@@ -0,0 +1,105 @@
+package class03;
+
+import java.util.Stack;
+
+public class Code05_GetMinStack {
+
+	public static class MyStack1 {
+		private Stack<Integer> stackData;
+		private Stack<Integer> stackMin;
+
+		public MyStack1() {
+			this.stackData = new Stack<Integer>();
+			this.stackMin = new Stack<Integer>();
+		}
+
+		public void push(int newNum) {
+			if (this.stackMin.isEmpty()) {
+				this.stackMin.push(newNum);
+			} else if (newNum <= this.getmin()) {
+				this.stackMin.push(newNum);
+			}
+			this.stackData.push(newNum);
+		}
+
+		public int pop() {
+			if (this.stackData.isEmpty()) {
+				throw new RuntimeException("Your stack is empty.");
+			}
+			int value = this.stackData.pop();
+			if (value == this.getmin()) {
+				this.stackMin.pop();
+			}
+			return value;
+		}
+
+		public int getmin() {
+			if (this.stackMin.isEmpty()) {
+				throw new RuntimeException("Your stack is empty.");
+			}
+			return this.stackMin.peek();
+		}
+	}
+
+	public static class MyStack2 {
+		private Stack<Integer> stackData;
+		private Stack<Integer> stackMin;
+
+		public MyStack2() {
+			this.stackData = new Stack<Integer>();
+			this.stackMin = new Stack<Integer>();
+		}
+
+		public void push(int newNum) {
+			if (this.stackMin.isEmpty()) {
+				this.stackMin.push(newNum);
+			} else if (newNum < this.getmin()) {
+				this.stackMin.push(newNum);
+			} else {
+				int newMin = this.stackMin.peek();
+				this.stackMin.push(newMin);
+			}
+			this.stackData.push(newNum);
+		}
+
+		public int pop() {
+			if (this.stackData.isEmpty()) {
+				throw new RuntimeException("Your stack is empty.");
+			}
+			this.stackMin.pop();
+			return this.stackData.pop();
+		}
+
+		public int getmin() {
+			if (this.stackMin.isEmpty()) {
+				throw new RuntimeException("Your stack is empty.");
+			}
+			return this.stackMin.peek();
+		}
+	}
+
+	public static void main(String[] args) {
+		MyStack1 stack1 = new MyStack1();
+		stack1.push(3);
+		System.out.println(stack1.getmin());
+		stack1.push(4);
+		System.out.println(stack1.getmin());
+		stack1.push(1);
+		System.out.println(stack1.getmin());
+		System.out.println(stack1.pop());
+		System.out.println(stack1.getmin());
+
+		System.out.println("=============");
+
+		MyStack1 stack2 = new MyStack1();
+		stack2.push(3);
+		System.out.println(stack2.getmin());
+		stack2.push(4);
+		System.out.println(stack2.getmin());
+		stack2.push(1);
+		System.out.println(stack2.getmin());
+		System.out.println(stack2.pop());
+		System.out.println(stack2.getmin());
+	}
+
+}

src/class03/Code06_TwoStacksImplementQueue.java

@@ -0,0 +1,60 @@
+package class03;
+
+import java.util.Stack;
+
+public class Code06_TwoStacksImplementQueue {
+
+	public static class TwoStacksQueue {
+		public Stack<Integer> stackPush;
+		public Stack<Integer> stackPop;
+
+		public TwoStacksQueue() {
+			stackPush = new Stack<Integer>();
+			stackPop = new Stack<Integer>();
+		}
+
+		// push栈向pop栈倒入数据
+		private void pushToPop() {
+			if (stackPop.empty()) {
+				while (!stackPush.empty()) {
+					stackPop.push(stackPush.pop());
+				}
+			}
+		}
+
+		public void add(int pushInt) {
+			stackPush.push(pushInt);
+			pushToPop();
+		}
+
+		public int poll() {
+			if (stackPop.empty() && stackPush.empty()) {
+				throw new RuntimeException("Queue is empty!");
+			}
+			pushToPop();
+			return stackPop.pop();
+		}
+
+		public int peek() {
+			if (stackPop.empty() && stackPush.empty()) {
+				throw new RuntimeException("Queue is empty!");
+			}
+			pushToPop();
+			return stackPop.peek();
+		}
+	}
+
+	public static void main(String[] args) {
+		TwoStacksQueue test = new TwoStacksQueue();
+		test.add(1);
+		test.add(2);
+		test.add(3);
+		System.out.println(test.peek());
+		System.out.println(test.poll());
+		System.out.println(test.peek());
+		System.out.println(test.poll());
+		System.out.println(test.peek());
+		System.out.println(test.poll());
+	}
+
+}

src/class03/Code07_TwoQueueImplementStack.java

@@ -0,0 +1,90 @@
+package class03;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class Code07_TwoQueueImplementStack {
+
+	public static class TwoQueueStack<T> {
+		public Queue<T> queue;
+		public Queue<T> help;
+
+		public TwoQueueStack() {
+			queue = new LinkedList<>();
+			help = new LinkedList<>();
+		}
+
+		public void push(T value) {
+			queue.offer(value);
+		}
+
+		public T poll() {
+			while (queue.size() > 1) {
+				help.offer(queue.poll());
+			}
+			T ans = queue.poll();
+			Queue<T> tmp = queue;
+			queue = help;
+			help = tmp;
+			return ans;
+		}
+
+		public T peek() {
+			while (queue.size() > 1) {
+				help.offer(queue.poll());
+			}
+			T ans = queue.poll();
+			help.offer(ans);
+			Queue<T> tmp = queue;
+			queue = help;
+			help = tmp;
+			return ans;
+		}
+
+		public boolean isEmpty() {
+			return queue.isEmpty();
+		}
+
+	}
+
+	public static void main(String[] args) {
+		System.out.println("test begin");
+		TwoQueueStack<Integer> myStack = new TwoQueueStack<>();
+		Stack<Integer> test = new Stack<>();
+		int testTime = 1000000;
+		int max = 1000000;
+		for (int i = 0; i < testTime; i++) {
+			if (myStack.isEmpty()) {
+				if (!test.isEmpty()) {
+					System.out.println("Oops");
+				}
+				int num = (int) (Math.random() * max);
+				myStack.push(num);
+				test.push(num);
+			} else {
+				if (Math.random() < 0.25) {
+					int num = (int) (Math.random() * max);
+					myStack.push(num);
+					test.push(num);
+				} else if (Math.random() < 0.5) {
+					if (!myStack.peek().equals(test.peek())) {
+						System.out.println("Oops");
+					}
+				} else if (Math.random() < 0.75) {
+					if (!myStack.poll().equals(test.pop())) {
+						System.out.println("Oops");
+					}
+				} else {
+					if (myStack.isEmpty() != test.isEmpty()) {
+						System.out.println("Oops");
+					}
+				}
+			}
+		}
+
+		System.out.println("test finish!");
+
+	}
+
+}

src/class03/Code08_GetMax.java

@@ -0,0 +1,24 @@
+package class03;
+
+public class Code08_GetMax {
+
+	// 求arr中的最大值
+	public static int getMax(int[] arr) {
+		return process(arr, 0, arr.length - 1);
+	}
+
+	// arr[L..R]范围上求最大值  L ... R   N
+	public static int process(int[] arr, int L, int R) {
+		// 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);
+		return Math.max(leftMax, rightMax);
+	}
+
+}

src/class03/HashMapAndSortedMap.java

@@ -0,0 +1,128 @@
+package class03;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.TreeMap;
+
+public class HashMapAndSortedMap {
+
+	public static class Node {
+		public int value;
+
+		public Node(int 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");
+		map.put(2, "我是2");
+		map.put(3, "我是3");
+		map.put(4, "我是4");
+		map.put(5, "我是5");
+		map.put(6, "我是6");
+		map.put(1000000, "我是1000001");
+
+		System.out.println(map.containsKey(1));
+		System.out.println(map.containsKey(10));
+
+		System.out.println(map.get(4));
+		System.out.println(map.get(10));
+
+		map.put(4, "他是4");
+		System.out.println(map.get(4));
+
+		map.remove(4);
+		System.out.println(map.get(4));
+
+		// key
+		HashSet<String> set = new HashSet<>();
+		set.add("abc");
+		set.contains("abc");
+		set.remove("abc");
+
+		// 哈希表，增、删、改、查，在使用时，O（1）
+
+		System.out.println("=====================");
+
+		Integer c = 100000;
+		Integer d = 100000;
+		System.out.println(c.equals(d));
+
+		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;
+		map2.put(node1, "我是node1");
+		map2.put(node2, "我是node1");
+		System.out.println(map2.size());
+
+		System.out.println("======================");
+
+		// TreeMap 有序表：接口名
+		// 红黑树、avl、sb树、跳表
+		// O(logN)
+		System.out.println("有序表测试开始");
+		TreeMap<Integer, String> treeMap = new TreeMap<>();
+
+		treeMap.put(3, "我是3");
+		treeMap.put(4, "我是4");
+		treeMap.put(8, "我是8");
+		treeMap.put(5, "我是5");
+		treeMap.put(7, "我是7");
+		treeMap.put(1, "我是1");
+		treeMap.put(2, "我是2");
+
+		System.out.println(treeMap.containsKey(1));
+		System.out.println(treeMap.containsKey(10));
+
+		System.out.println(treeMap.get(4));
+		System.out.println(treeMap.get(10));
+
+		treeMap.put(4, "他是4");
+		System.out.println(treeMap.get(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/class04/Code01_MergeSort.java

@@ -0,0 +1,147 @@
+package class04;
+
+public class Code01_MergeSort {
+
+	// 递归方法实现
+	public static void mergeSort1(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		process(arr, 0, arr.length - 1);
+	}
+
+	// 请把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;
+		}
+		int mid = L + ((R - L) >> 1);
+		process(arr, L, mid);
+		process(arr, mid + 1, R);
+		merge(arr, L, mid, R);
+	}
+
+	public static void merge(int[] arr, int L, int M, int R) {
+		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++];
+		}
+		// 要么p1越界了，要么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];
+		}
+	}
+
+	// 非递归方法实现
+	public static void mergeSort2(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		int N = arr.length;
+		// 步长
+		int mergeSize = 1;
+		while (mergeSize < N) { // log N
+			// 当前左组的，第一个位置
+			int L = 0;
+			while (L < N) {
+				if (mergeSize >= N - L) {
+					break;
+				}
+				int M = L + mergeSize - 1;
+				int R = M + Math.min(mergeSize, N - M - 1);
+				merge(arr, L, M, R);
+				L = R + 1;
+			}
+			// 防止溢出
+			if (mergeSize > N / 2) {
+				break;
+			}
+			mergeSize <<= 1;
+		}
+	}
+
+	// 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);
+			mergeSort1(arr1);
+			mergeSort2(arr2);
+			if (!isEqual(arr1, arr2)) {
+				System.out.println("出错了！");
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class04/Code02_SmallSum.java

@@ -0,0 +1,137 @@
+package class04;
+
+public class Code02_SmallSum {
+
+	public static int smallSum(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return 0;
+		}
+		return process(arr, 0, arr.length - 1);
+	}
+
+	// arr[L..R]既要排好序，也要求小和返回
+	// 所有merge时，产生的小和，累加
+	// 左 排序   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 = 0;
+		int p1 = L;
+		int p2 = m + 1;
+		int res = 0;
+		while (p1 <= m && p2 <= r) {
+			res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
+			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 res;
+	}
+
+	// for test
+	public static int comparator(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return 0;
+		}
+		int res = 0;
+		for (int i = 1; i < arr.length; i++) {
+			for (int j = 0; j < i; j++) {
+				res += arr[j] < arr[i] ? arr[j] : 0;
+			}
+		}
+		return res;
+	}
+
+	// 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;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			if (smallSum(arr1) != comparator(arr2)) {
+				succeed = false;
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+	}
+
+}

src/class04/Code03_ReversePair.java

@@ -0,0 +1,130 @@
+package class04;
+
+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/class04/Code04_BiggerThanRightTwice.java

@@ -0,0 +1,135 @@
+package class04;
+
+//  本题测试链接 : https://leetcode.com/problems/reverse-pairs/
+public class Code04_BiggerThanRightTwice {
+
+	public static int reversePairs(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) {
+		// [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 && (long) arr[i] > (long) arr[windowR] * 2) {
+				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 (reversePairs(arr1) != comparator(arr2)) {
+				System.out.println("Oops!");
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class05/Code01_CountOfRangeSum.java

@@ -0,0 +1,63 @@
+package class05;
+
+// 这道题直接在leetcode测评：
+// https://leetcode.com/problems/count-of-range-sum/
+public class Code01_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;
+		// [windowL, windowR)
+		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 += 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/class05/Code02_PartitionAndQuickSort.java

@@ -0,0 +1,197 @@
+package class05;
+
+public class Code02_PartitionAndQuickSort {
+
+	public static void swap(int[] arr, int i, int j) {
+		int tmp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = tmp;
+	}
+
+	// arr[L..R]上，以arr[R]位置的数做划分值
+	// <= X > X
+	// <= X X
+	public static int partition(int[] arr, int L, int R) {
+		if (L > R) {
+			return -1;
+		}
+		if (L == R) {
+			return L;
+		}
+		int lessEqual = L - 1;
+		int index = L;
+		while (index < R) {
+			if (arr[index] <= arr[R]) {
+				swap(arr, index, ++lessEqual);
+			}
+			index++;
+		}
+		swap(arr, ++lessEqual, R);
+		return lessEqual;
+	}
+
+	// arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
+	// <arr[R] ==arr[R] > arr[R]
+	public static int[] netherlandsFlag(int[] arr, int L, int R) {
+		if (L > R) { // L...R L>R
+			return new int[] { -1, -1 };
+		}
+		if (L == R) {
+			return new int[] { L, R };
+		}
+		int less = L - 1; // < 区 右边界
+		int more = R; // > 区 左边界
+		int index = L;
+		while (index < more) { // 当前位置，不能和 >区的左边界撞上
+			if (arr[index] == arr[R]) {
+				index++;
+			} else if (arr[index] < arr[R]) {
+//				swap(arr, less + 1, index);
+//				less++;
+//				index++;						
+				swap(arr, index++, ++less);
+			} else { // >
+				swap(arr, index, --more);
+			}
+		}
+		swap(arr, more, R); // <[R]   =[R]   >[R]
+		return new int[] { less + 1, more };
+	}
+
+	public static void quickSort1(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		process1(arr, 0, arr.length - 1);
+	}
+
+	public static void process1(int[] arr, int L, int R) {
+		if (L >= R) {
+			return;
+		}
+		// L..R partition arr[R] [ <=arr[R] arr[R] >arr[R] ]
+		int M = partition(arr, L, R);
+		process1(arr, L, M - 1);
+		process1(arr, M + 1, R);
+	}
+
+	
+	
+	
+	
+	
+	public static void quickSort2(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		process2(arr, 0, arr.length - 1);
+	}
+
+	// arr[L...R] 排有序，快排2.0方式
+	public static void process2(int[] arr, int L, int R) {
+		if (L >= R) {
+			return;
+		}
+		// [ equalArea[0]  ,  equalArea[0]]
+		int[] equalArea = netherlandsFlag(arr, L, R);
+		process2(arr, L, equalArea[0] - 1);
+		process2(arr, equalArea[1] + 1, R);
+	}
+
+	
+	
+	
+	
+	
+	
+	public static void quickSort3(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		process3(arr, 0, arr.length - 1);
+	}
+
+	public static void process3(int[] arr, int L, int R) {
+		if (L >= R) {
+			return;
+		}
+		swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
+		int[] equalArea = netherlandsFlag(arr, L, R);
+		process3(arr, L, equalArea[0] - 1);
+		process3(arr, equalArea[1] + 1, R);
+	}
+
+	// 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;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			int[] arr3 = copyArray(arr1);
+			quickSort1(arr1);
+			quickSort2(arr2);
+			quickSort3(arr3);
+			if (!isEqual(arr1, arr2) || !isEqual(arr2, arr3)) {
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Oops!");
+
+	}
+
+}

src/class05/Code03_QuickSortRecursiveAndUnrecursive.java

@@ -0,0 +1,195 @@
+package class05;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class Code03_QuickSortRecursiveAndUnrecursive {
+
+	// 荷兰国旗问题
+	public static int[] netherlandsFlag(int[] arr, int L, int R) {
+		if (L > R) {
+			return new int[] { -1, -1 };
+		}
+		if (L == R) {
+			return new int[] { L, R };
+		}
+		int less = L - 1;
+		int more = R;
+		int index = L;
+		while (index < more) {
+			if (arr[index] == arr[R]) {
+				index++;
+			} else if (arr[index] < arr[R]) {
+				swap(arr, index++, ++less);
+			} else {
+				swap(arr, index, --more);
+			}
+		}
+		swap(arr, more, R);
+		return new int[] { less + 1, more };
+	}
+
+	public static void swap(int[] arr, int i, int j) {
+		int tmp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = tmp;
+	}
+
+	// 快排递归版本
+	public static void quickSort1(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;
+		}
+		swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
+		int[] equalArea = netherlandsFlag(arr, L, R);
+		process(arr, L, equalArea[0] - 1);
+		process(arr, equalArea[1] + 1, R);
+	}
+
+	// 快排非递归版本需要的辅助类
+	// 要处理的是什么范围上的排序
+	public static class Op {
+		public int l;
+		public int r;
+
+		public Op(int left, int right) {
+			l = left;
+			r = right;
+		}
+	}
+
+	// 快排3.0 非递归版本 用栈来执行
+	public static void quickSort2(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		int N = arr.length;
+		swap(arr, (int) (Math.random() * N), N - 1);
+		int[] equalArea = netherlandsFlag(arr, 0, N - 1);
+		int el = equalArea[0];
+		int er = equalArea[1];
+		Stack<Op> stack = new Stack<>();
+		stack.push(new Op(0, el - 1));
+		stack.push(new Op(er + 1, N - 1));
+		while (!stack.isEmpty()) {
+			Op op = stack.pop(); // op.l ... op.r
+			if (op.l < op.r) {
+				swap(arr, op.l + (int) (Math.random() * (op.r - op.l + 1)), op.r);
+				equalArea = netherlandsFlag(arr, op.l, op.r);
+				el = equalArea[0];
+				er = equalArea[1];
+				stack.push(new Op(op.l, el - 1));
+				stack.push(new Op(er + 1, op.r));
+			}
+		}
+	}
+
+	// 快排3.0 非递归版本 用队列来执行
+	public static void quickSort3(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		int N = arr.length;
+		swap(arr, (int) (Math.random() * N), N - 1);
+		int[] equalArea = netherlandsFlag(arr, 0, N - 1);
+		int el = equalArea[0];
+		int er = equalArea[1];
+		Queue<Op> queue = new LinkedList<>();
+		queue.offer(new Op(0, el - 1));
+		queue.offer(new Op(er + 1, N - 1));
+		while (!queue.isEmpty()) {
+			Op op = queue.poll();
+			if (op.l < op.r) {
+				swap(arr, op.l + (int) (Math.random() * (op.r - op.l + 1)), op.r);
+				equalArea = netherlandsFlag(arr, op.l, op.r);
+				el = equalArea[0];
+				er = equalArea[1];
+				queue.offer(new Op(op.l, el - 1));
+				queue.offer(new Op(er + 1, op.r));
+			}
+		}
+	}
+
+	// 生成随机数组（用于测试）
+	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;
+	}
+
+	// 拷贝数组（用于测试）
+	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;
+	}
+
+	// 对比两个数组（用于测试）
+	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;
+	}
+
+	// 打印数组（用于测试）
+	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();
+	}
+
+	// 跑大样本随机测试（对数器）
+	public static void main(String[] args) {
+		int testTime = 500000;
+		int maxSize = 100;
+		int maxValue = 100;
+		boolean succeed = true;
+		System.out.println("test begin");
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			int[] arr3 = copyArray(arr1);
+			quickSort1(arr1);
+			quickSort2(arr2);
+			quickSort3(arr3);
+			if (!isEqual(arr1, arr2) || !isEqual(arr1, arr3)) {
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println("test end");
+		System.out.println("测试" + testTime + "组是否全部通过：" + (succeed ? "是" : "否"));
+	}
+
+}

src/class05/Code04_DoubleLinkedListQuickSort.java

@@ -0,0 +1,300 @@
+package class05;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+
+// 双向链表的随机快速排序
+// 课上没有讲，因为这是群里同学问的问题
+// 作为补充放在这，有需要的同学可以看看
+// 和课上讲的数组的经典快速排序在算法上没有区别
+// 但是coding需要更小心
+public class Code04_DoubleLinkedListQuickSort {
+
+	public static class Node {
+		public int value;
+		public Node last;
+		public Node next;
+
+		public Node(int v) {
+			value = v;
+		}
+	}
+
+	public static Node quickSort(Node h) {
+		if (h == null) {
+			return null;
+		}
+		int N = 0;
+		Node c = h;
+		Node e = null;
+		while (c != null) {
+			N++;
+			e = c;
+			c = c.next;
+		}
+		return process(h, e, N).h;
+	}
+
+	public static class HeadTail {
+		public Node h;
+		public Node t;
+
+		public HeadTail(Node head, Node tail) {
+			h = head;
+			t = tail;
+		}
+	}
+
+	// L...R是一个双向链表的头和尾,
+	// L的last指针指向null，R的next指针指向null
+	// 也就是说L的左边没有，R的右边也没节点
+	// 就是一个正常的双向链表，一共有N个节点
+	// 将这一段用随机快排的方式排好序
+	// 返回排好序之后的双向链表的头和尾(HeadTail)
+	public static HeadTail process(Node L, Node R, int N) {
+		if (L == null) {
+			return null;
+		}
+		if (L == R) {
+			return new HeadTail(L, R);
+		}
+		// L..R上不只一个节点
+		// 随机得到一个随机下标
+		int randomIndex = (int) (Math.random() * N);
+		// 根据随机下标得到随机节点
+		Node randomNode = L;
+		while (randomIndex-- != 0) {
+			randomNode = randomNode.next;
+		}
+		// 把随机节点从原来的环境里分离出来
+		// 比如 a(L) -> b -> c -> d(R), 如果randomNode = c，那么调整之后
+		// a(L) -> b -> d(R), c会被挖出来，randomNode = c
+		if (randomNode == L || randomNode == R) {
+			if (randomNode == L) {
+				L = randomNode.next;
+				L.last = null;
+			} else {
+				randomNode.last.next = null;
+			}
+		} else { // randomNode一定是中间的节点
+			randomNode.last.next = randomNode.next;
+			randomNode.next.last = randomNode.last;
+		}
+		randomNode.last = null;
+		randomNode.next = null;
+		Info info = partition(L, randomNode);
+		// <randomNode的部分去排序
+		HeadTail lht = process(info.lh, info.lt, info.ls);
+		// >randomNode的部分去排序
+		HeadTail rht = process(info.rh, info.rt, info.rs);
+		// 左部分排好序、右部分排好序
+		// 把它们串在一起
+		if (lht != null) {
+			lht.t.next = info.eh;
+			info.eh.last = lht.t;
+		}
+		if (rht != null) {
+			info.et.next = rht.h;
+			rht.h.last = info.et;
+		}
+		// 返回排好序之后总的头和总的尾
+		Node h = lht != null ? lht.h : info.eh;
+		Node t = rht != null ? rht.t : info.et;
+		return new HeadTail(h, t);
+	}
+
+	public static class Info {
+		public Node lh;
+		public Node lt;
+		public int ls;
+		public Node rh;
+		public Node rt;
+		public int rs;
+		public Node eh;
+		public Node et;
+
+		public Info(Node lH, Node lT, int lS, Node rH, Node rT, int rS, Node eH, Node eT) {
+			lh = lH;
+			lt = lT;
+			ls = lS;
+			rh = rH;
+			rt = rT;
+			rs = rS;
+			eh = eH;
+			et = eT;
+		}
+	}
+
+	// (L....一直到空)，是一个双向链表
+	// pivot是一个不在(L....一直到空)的独立节点，它作为划分值
+	// 根据荷兰国旗问题的划分方式，把(L....一直到空)划分成:
+	// <pivot 、 =pivot 、 >pivot 三个部分，然后把pivot融进=pivot的部分
+	// 比如 4(L)->6->7->1->5->0->9->null pivot=5(这个5和链表中的5，是不同的节点)
+	// 调整完成后:
+	// 4->1->0 小于的部分
+	// 5->5 等于的部分
+	// 6->7->9 大于的部分
+	// 三个部分是断开的
+	// 然后返回Info：
+	// 小于部分的头、尾、节点个数 : lh,lt,ls
+	// 大于部分的头、尾、节点个数 : rh,rt,rs
+	// 等于部分的头、尾 : eh,et
+	public static Info partition(Node L, Node pivot) {
+		Node lh = null;
+		Node lt = null;
+		int ls = 0;
+		Node rh = null;
+		Node rt = null;
+		int rs = 0;
+		Node eh = pivot;
+		Node et = pivot;
+		Node tmp = null;
+		while (L != null) {
+			tmp = L.next;
+			L.next = null;
+			L.last = null;
+			if (L.value < pivot.value) {
+				ls++;
+				if (lh == null) {
+					lh = L;
+					lt = L;
+				} else {
+					lt.next = L;
+					L.last = lt;
+					lt = L;
+				}
+			} else if (L.value > pivot.value) {
+				rs++;
+				if (rh == null) {
+					rh = L;
+					rt = L;
+				} else {
+					rt.next = L;
+					L.last = rt;
+					rt = L;
+				}
+			} else {
+				et.next = L;
+				L.last = et;
+				et = L;
+			}
+			L = tmp;
+		}
+		return new Info(lh, lt, ls, rh, rt, rs, eh, et);
+	}
+
+	// 为了测试
+	public static class NodeComp implements Comparator<Node> {
+
+		@Override
+		public int compare(Node o1, Node o2) {
+			return o1.value - o2.value;
+		}
+
+	}
+
+	// 为了测试
+	public static Node sort(Node head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<Node> arr = new ArrayList<>();
+		while (head != null) {
+			arr.add(head);
+			head = head.next;
+		}
+		arr.sort(new NodeComp());
+		Node h = arr.get(0);
+		h.last = null;
+		Node p = h;
+		for (int i = 1; i < arr.size(); i++) {
+			Node c = arr.get(i);
+			p.next = c;
+			c.last = p;
+			c.next = null;
+			p = c;
+		}
+		return h;
+	}
+
+	// 为了测试
+	public static Node generateRandomDoubleLinkedList(int n, int v) {
+		if (n == 0) {
+			return null;
+		}
+		Node[] arr = new Node[n];
+		for (int i = 0; i < n; i++) {
+			arr[i] = new Node((int) (Math.random() * v));
+		}
+		Node head = arr[0];
+		Node pre = head;
+		for (int i = 1; i < n; i++) {
+			pre.next = arr[i];
+			arr[i].last = pre;
+			pre = arr[i];
+		}
+		return head;
+	}
+
+	// 为了测试
+	public static Node cloneDoubleLinkedList(Node head) {
+		if (head == null) {
+			return null;
+		}
+		Node h = new Node(head.value);
+		Node p = h;
+		head = head.next;
+		while (head != null) {
+			Node c = new Node(head.value);
+			p.next = c;
+			c.last = p;
+			p = c;
+			head = head.next;
+		}
+		return h;
+	}
+
+	// 为了测试
+	public static boolean equal(Node h1, Node h2) {
+		return doubleLinkedListToString(h1).equals(doubleLinkedListToString(h2));
+	}
+
+	// 为了测试
+	public static String doubleLinkedListToString(Node head) {
+		Node cur = head;
+		Node end = null;
+		StringBuilder builder = new StringBuilder();
+		while (cur != null) {
+			builder.append(cur.value + " ");
+			end = cur;
+			cur = cur.next;
+		}
+		builder.append("| ");
+		while (end != null) {
+			builder.append(end.value + " ");
+			end = end.last;
+		}
+		return builder.toString();
+	}
+
+	// 为了测试
+	public static void main(String[] args) {
+		int N = 500;
+		int V = 500;
+		int testTime = 10000;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTime; i++) {
+			int size = (int) (Math.random() * N);
+			Node head1 = generateRandomDoubleLinkedList(size, V);
+			Node head2 = cloneDoubleLinkedList(head1);
+			Node sort1 = quickSort(head1);
+			Node sort2 = sort(head2);
+			if (!equal(sort1, sort2)) {
+				System.out.println("出错了!");
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class06/Code01_Comparator.java

@@ -0,0 +1,168 @@
+package class06;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.TreeMap;
+
+public class Code01_Comparator {
+
+	public static class Student {
+		public String name;
+		public int id;
+		public int age;
+
+		public Student(String name, int id, int age) {
+			this.name = name;
+			this.id = id;
+			this.age = age;
+		}
+	}
+
+	// 任何比较器：
+	// compare方法里，遵循一个统一的规范：
+	// 返回负数的时候，认为第一个参数应该排在前面
+	// 返回正数的时候，认为第二个参数应该排在前面
+	// 返回0的时候，认为无所谓谁放前面
+	public static class IdShengAgeJiangOrder implements Comparator<Student> {
+
+		// 根据id从小到大，但是如果id一样，按照年龄从大到小
+		@Override
+		public int compare(Student o1, Student o2) {
+			return o1.id != o2.id ? (o1.id - o2.id) : (o2.age - o1.age);
+		}
+
+	}
+
+	public static class IdAscendingComparator implements Comparator<Student> {
+
+		// 返回负数的时候，第一个参数排在前面
+		// 返回正数的时候，第二个参数排在前面
+		// 返回0的时候，谁在前面无所谓
+		@Override
+		public int compare(Student o1, Student o2) {
+			return o1.id - o2.id;
+		}
+
+	}
+
+	public static class IdDescendingComparator implements Comparator<Student> {
+
+		@Override
+		public int compare(Student o1, Student o2) {
+			return o2.id - o1.id;
+		}
+
+	}
+
+	// 先按照id排序，id小的，放前面；
+	// id一样，age大的，前面；
+	public static class IdInAgeDe implements Comparator<Student> {
+
+		@Override
+		public int compare(Student o1, Student o2) {
+			return o1.id != o2.id ? o1.id - o2.id : (o2.age - o1.age);
+		}
+
+	}
+
+	public static void printStudents(Student[] students) {
+		for (Student student : students) {
+			System.out.println("Name : " + student.name + ", Id : " + student.id + ", Age : " + student.age);
+		}
+	}
+
+	public static void printArray(Integer[] arr) {
+		if (arr == null) {
+			return;
+		}
+		for (int i = 0; i < arr.length; i++) {
+			System.out.print(arr[i] + " ");
+		}
+		System.out.println();
+	}
+
+	public static class MyComp implements Comparator<Integer> {
+
+		@Override
+		public int compare(Integer o1, Integer o2) {
+			return o2 - o1;
+		}
+
+	}
+
+	public static class AComp implements Comparator<Integer> {
+
+		// 如果返回负数，认为第一个参数应该拍在前面
+		// 如果返回正数，认为第二个参数应该拍在前面
+		// 如果返回0，认为谁放前面都行
+		@Override
+		public int compare(Integer arg0, Integer arg1) {
+
+			return arg1 - arg0;
+
+//			return 0;
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		Integer[] arr = { 5, 4, 3, 2, 7, 9, 1, 0 };
+
+		Arrays.sort(arr, new AComp());
+
+		for (int i = 0; i < arr.length; i++) {
+			System.out.println(arr[i]);
+		}
+
+		System.out.println("===========================");
+
+		Student student1 = new Student("A", 4, 40);
+		Student student2 = new Student("B", 4, 21);
+		Student student3 = new Student("C", 3, 12);
+		Student student4 = new Student("D", 3, 62);
+		Student student5 = new Student("E", 3, 42);
+		// D E C A B
+
+		Student[] students = new Student[] { student1, student2, student3, student4, student5 };
+		System.out.println("第一条打印");
+
+		Arrays.sort(students, new IdShengAgeJiangOrder());
+		for (int i = 0; i < students.length; i++) {
+			Student s = students[i];
+			System.out.println(s.name + "," + s.id + "," + s.age);
+		}
+
+		System.out.println("第二条打印");
+		ArrayList<Student> studentList = new ArrayList<>();
+		studentList.add(student1);
+		studentList.add(student2);
+		studentList.add(student3);
+		studentList.add(student4);
+		studentList.add(student5);
+		studentList.sort(new IdShengAgeJiangOrder());
+		for (int i = 0; i < studentList.size(); i++) {
+			Student s = studentList.get(i);
+			System.out.println(s.name + "," + s.id + "," + s.age);
+		}
+		// N * logN
+		System.out.println("第三条打印");
+		student1 = new Student("A", 4, 40);
+		student2 = new Student("B", 4, 21);
+		student3 = new Student("C", 4, 12);
+		student4 = new Student("D", 4, 62);
+		student5 = new Student("E", 4, 42);
+		TreeMap<Student, String> treeMap = new TreeMap<>((a, b) -> (a.id - b.id));
+		treeMap.put(student1, "我是学生1，我的名字叫A");
+		treeMap.put(student2, "我是学生2，我的名字叫B");
+		treeMap.put(student3, "我是学生3，我的名字叫C");
+		treeMap.put(student4, "我是学生4，我的名字叫D");
+		treeMap.put(student5, "我是学生5，我的名字叫E");
+		for (Student s : treeMap.keySet()) {
+			System.out.println(s.name + "," + s.id + "," + s.age);
+		}
+
+	}
+
+}

src/class06/Code02_Heap.java

@@ -0,0 +1,192 @@
+package class06;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Code02_Heap {
+
+	public static class MyMaxHeap {
+		private int[] heap;
+		private final int limit;
+		private int heapSize;
+
+		public MyMaxHeap(int limit) {
+			heap = new int[limit];
+			this.limit = limit;
+			heapSize = 0;
+		}
+
+		public boolean isEmpty() {
+			return heapSize == 0;
+		}
+
+		public boolean isFull() {
+			return heapSize == limit;
+		}
+
+		public void push(int value) {
+			if (heapSize == limit) {
+				throw new RuntimeException("heap is full");
+			}
+			heap[heapSize] = value;
+			// value heapSize
+			heapInsert(heap, heapSize++);
+		}
+
+		// 用户此时，让你返回最大值，并且在大根堆中，把最大值删掉
+		// 剩下的数，依然保持大根堆组织
+		public int pop() {
+			int ans = heap[0];
+			swap(heap, 0, --heapSize);
+			heapify(heap, 0, heapSize);
+			return ans;
+		}
+
+		// 新加进来的数，现在停在了index位置，请依次往上移动，
+		// 移动到0位置，或者干不掉自己的父亲了，停！
+		private void heapInsert(int[] arr, int index) {
+			// [index] [index-1]/2
+			// index == 0
+			while (arr[index] > arr[(index - 1) / 2]) {
+				swap(arr, index, (index - 1) / 2);
+				index = (index - 1) / 2;
+			}
+		}
+
+		// 从index位置，往下看，不断的下沉
+		// 停：较大的孩子都不再比index位置的数大；已经没孩子了
+		private void heapify(int[] arr, int index, int heapSize) {
+			int left = index * 2 + 1;
+			while (left < heapSize) { // 如果有左孩子，有没有右孩子，可能有可能没有！
+				// 把较大孩子的下标，给largest
+				int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
+				largest = arr[largest] > arr[index] ? largest : index;
+				if (largest == index) {
+					break;
+				}
+				// index和较大孩子，要互换
+				swap(arr, largest, index);
+				index = largest;
+				left = index * 2 + 1;
+			}
+		}
+
+		private void swap(int[] arr, int i, int j) {
+			int tmp = arr[i];
+			arr[i] = arr[j];
+			arr[j] = tmp;
+		}
+
+	}
+
+	public static class RightMaxHeap {
+		private int[] arr;
+		private final int limit;
+		private int size;
+
+		public RightMaxHeap(int limit) {
+			arr = new int[limit];
+			this.limit = limit;
+			size = 0;
+		}
+
+		public boolean isEmpty() {
+			return size == 0;
+		}
+
+		public boolean isFull() {
+			return size == limit;
+		}
+
+		public void push(int value) {
+			if (size == limit) {
+				throw new RuntimeException("heap is full");
+			}
+			arr[size++] = value;
+		}
+
+		public int pop() {
+			int maxIndex = 0;
+			for (int i = 1; i < size; i++) {
+				if (arr[i] > arr[maxIndex]) {
+					maxIndex = i;
+				}
+			}
+			int ans = arr[maxIndex];
+			arr[maxIndex] = arr[--size];
+			return ans;
+		}
+
+	}
+
+	public static class MyComparator implements Comparator<Integer> {
+
+		@Override
+		public int compare(Integer o1, Integer o2) {
+			return o2 - o1;
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		// 小根堆
+		PriorityQueue<Integer> heap = new PriorityQueue<>(new MyComparator());
+		heap.add(5);
+		heap.add(5);
+		heap.add(5);
+		heap.add(3);
+		// 5 , 3
+		System.out.println(heap.peek());
+		heap.add(7);
+		heap.add(0);
+		heap.add(7);
+		heap.add(0);
+		heap.add(7);
+		heap.add(0);
+		System.out.println(heap.peek());
+		while (!heap.isEmpty()) {
+			System.out.println(heap.poll());
+		}
+
+		int value = 1000;
+		int limit = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			int curLimit = (int) (Math.random() * limit) + 1;
+			MyMaxHeap my = new MyMaxHeap(curLimit);
+			RightMaxHeap test = new RightMaxHeap(curLimit);
+			int curOpTimes = (int) (Math.random() * limit);
+			for (int j = 0; j < curOpTimes; j++) {
+				if (my.isEmpty() != test.isEmpty()) {
+					System.out.println("Oops!");
+				}
+				if (my.isFull() != test.isFull()) {
+					System.out.println("Oops!");
+				}
+				if (my.isEmpty()) {
+					int curValue = (int) (Math.random() * value);
+					my.push(curValue);
+					test.push(curValue);
+				} else if (my.isFull()) {
+					if (my.pop() != test.pop()) {
+						System.out.println("Oops!");
+					}
+				} else {
+					if (Math.random() < 0.5) {
+						int curValue = (int) (Math.random() * value);
+						my.push(curValue);
+						test.push(curValue);
+					} else {
+						if (my.pop() != test.pop()) {
+							System.out.println("Oops!");
+						}
+					}
+				}
+			}
+		}
+		System.out.println("finish!");
+
+	}
+
+}

src/class06/Code03_HeapSort.java

@@ -0,0 +1,158 @@
+package class06;
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Code03_HeapSort {
+
+	// 堆排序额外空间复杂度O(1)
+	public static void heapSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		// O(N*logN)
+//		for (int i = 0; i < arr.length; i++) { // O(N)
+//			heapInsert(arr, i); // O(logN)
+//		}
+		// O(N)
+		for (int i = arr.length - 1; i >= 0; i--) {
+			heapify(arr, i, arr.length);
+		}
+		int heapSize = arr.length;
+		swap(arr, 0, --heapSize);
+		// O(N*logN)
+		while (heapSize > 0) { // O(N)
+			heapify(arr, 0, heapSize); // O(logN)
+			swap(arr, 0, --heapSize); // O(1)
+		}
+	}
+
+	// arr[index]刚来的数，往上
+	public static void heapInsert(int[] arr, int index) {
+		while (arr[index] > arr[(index - 1) / 2]) {
+			swap(arr, index, (index - 1) / 2);
+			index = (index - 1) / 2;
+		}
+	}
+
+	// arr[index]位置的数，能否往下移动
+	public static void heapify(int[] arr, int index, int heapSize) {
+		int left = index * 2 + 1; // 左孩子的下标
+		while (left < heapSize) { // 下方还有孩子的时候
+			// 两个孩子中，谁的值大，把下标给largest
+			// 1）只有左孩子，left -> largest
+			// 2) 同时有左孩子和右孩子，右孩子的值<= 左孩子的值，left -> largest
+			// 3) 同时有左孩子和右孩子并且右孩子的值> 左孩子的值， right -> largest
+			int largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
+			// 父和较大的孩子之间，谁的值大，把下标给largest
+			largest = arr[largest] > arr[index] ? largest : index;
+			if (largest == index) {
+				break;
+			}
+			swap(arr, largest, index);
+			index = largest;
+			left = index * 2 + 1;
+		}
+	}
+
+	public static void swap(int[] arr, int i, int j) {
+		int tmp = arr[i];
+		arr[i] = arr[j];
+		arr[j] = tmp;
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// 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) {
+
+		// 默认小根堆
+		PriorityQueue<Integer> heap = new PriorityQueue<>();
+		heap.add(6);
+		heap.add(8);
+		heap.add(0);
+		heap.add(2);
+		heap.add(9);
+		heap.add(1);
+
+		while (!heap.isEmpty()) {
+			System.out.println(heap.poll());
+		}
+
+		int testTime = 500000;
+		int maxSize = 100;
+		int maxValue = 100;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			heapSort(arr1);
+			comparator(arr2);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		heapSort(arr);
+		printArray(arr);
+	}
+
+}

src/class06/Code04_SortArrayDistanceLessK.java

@@ -0,0 +1,127 @@
+package class06;
+
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Code04_SortArrayDistanceLessK {
+
+	public static void sortedArrDistanceLessK(int[] arr, int k) {
+		if (k == 0) {
+			return;
+		}
+		// 默认小根堆
+		PriorityQueue<Integer> heap = new PriorityQueue<>();
+		int index = 0;
+		// 0...K-1
+		for (; index <= Math.min(arr.length - 1, k - 1); index++) {
+			heap.add(arr[index]);
+		}
+		int i = 0;
+		for (; index < arr.length; i++, index++) {
+			heap.add(arr[index]);
+			arr[i] = heap.poll();
+		}
+		while (!heap.isEmpty()) {
+			arr[i++] = heap.poll();
+		}
+	}
+
+	// for test
+	public static void comparator(int[] arr, int k) {
+		Arrays.sort(arr);
+	}
+
+	// for test
+	public static int[] randomArrayNoMoveMoreK(int maxSize, int maxValue, int K) {
+		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());
+		}
+		// 先排个序
+		Arrays.sort(arr);
+		// 然后开始随意交换，但是保证每个数距离不超过K
+		// swap[i] == true, 表示i位置已经参与过交换
+		// swap[i] == false, 表示i位置没有参与过交换
+		boolean[] isSwap = new boolean[arr.length];
+		for (int i = 0; i < arr.length; i++) {
+			int j = Math.min(i + (int) (Math.random() * (K + 1)), arr.length - 1);
+			if (!isSwap[i] && !isSwap[j]) {
+				isSwap[i] = true;
+				isSwap[j] = true;
+				int tmp = arr[i];
+				arr[i] = arr[j];
+				arr[j] = tmp;
+			}
+		}
+		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) {
+		System.out.println("test begin");
+		int testTime = 500000;
+		int maxSize = 100;
+		int maxValue = 100;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int k = (int) (Math.random() * maxSize) + 1;
+			int[] arr = randomArrayNoMoveMoreK(maxSize, maxValue, k);
+			int[] arr1 = copyArray(arr);
+			int[] arr2 = copyArray(arr);
+			sortedArrDistanceLessK(arr1, k);
+			comparator(arr2, k);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				System.out.println("K : " + k);
+				printArray(arr);
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+	}
+
+}

src/class07/Code01_CoverMax.java

@@ -0,0 +1,155 @@
+package class07;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Code01_CoverMax {
+
+	public static int maxCover1(int[][] lines) {
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+		for (int i = 0; i < lines.length; i++) {
+			min = Math.min(min, lines[i][0]);
+			max = Math.max(max, lines[i][1]);
+		}
+		int cover = 0;
+		for (double p = min + 0.5; p < max; p += 1) {
+			int cur = 0;
+			for (int i = 0; i < lines.length; i++) {
+				if (lines[i][0] < p && lines[i][1] > p) {
+					cur++;
+				}
+			}
+			cover = Math.max(cover, cur);
+		}
+		return cover;
+	}
+
+	public static int maxCover2(int[][] m) {
+		Line[] lines = new Line[m.length];
+		for (int i = 0; i < m.length; i++) {
+			lines[i] = new Line(m[i][0], m[i][1]);
+		}
+		Arrays.sort(lines, new StartComparator());
+		// 小根堆，每一条线段的结尾数值，使用默认的
+		PriorityQueue<Integer> heap = new PriorityQueue<>();
+		int max = 0;
+		for (int i = 0; i < lines.length; i++) {
+			// lines[i] -> cur 在黑盒中，把<=cur.start 东西都弹出
+			while (!heap.isEmpty() && heap.peek() <= lines[i].start) {
+				heap.poll();
+			}
+			heap.add(lines[i].end);
+			max = Math.max(max, heap.size());
+		}
+		return max;
+	}
+
+	public static class Line {
+		public int start;
+		public int end;
+
+		public Line(int s, int e) {
+			start = s;
+			end = e;
+		}
+	}
+
+	public static class EndComparator implements Comparator<Line> {
+
+		@Override
+		public int compare(Line o1, Line o2) {
+			return o1.end - o2.end;
+		}
+
+	}
+
+	// 和maxCover2过程是一样的
+	// 只是代码更短
+	// 不使用类定义的写法
+	public static int maxCover3(int[][] m) {
+		// m是二维数组，可以认为m内部是一个一个的一维数组
+		// 每一个一维数组就是一个对象，也就是线段
+		// 如下的code，就是根据每一个线段的开始位置排序
+		// 比如, m = { {5,7}, {1,4}, {2,6} } 跑完如下的code之后变成：{ {1,4}, {2,6}, {5,7} }
+		Arrays.sort(m, (a, b) -> (a[0] - b[0]));
+		// 准备好小根堆，和课堂的说法一样
+		PriorityQueue<Integer> heap = new PriorityQueue<>();
+		int max = 0;
+		for (int[] line : m) {
+			while (!heap.isEmpty() && heap.peek() <= line[0]) {
+				heap.poll();
+			}
+			heap.add(line[1]);
+			max = Math.max(max, heap.size());
+		}
+		return max;
+	}
+
+	// for test
+	public static int[][] generateLines(int N, int L, int R) {
+		int size = (int) (Math.random() * N) + 1;
+		int[][] ans = new int[size][2];
+		for (int i = 0; i < size; i++) {
+			int a = L + (int) (Math.random() * (R - L + 1));
+			int b = L + (int) (Math.random() * (R - L + 1));
+			if (a == b) {
+				b = a + 1;
+			}
+			ans[i][0] = Math.min(a, b);
+			ans[i][1] = Math.max(a, b);
+		}
+		return ans;
+	}
+
+	public static class StartComparator implements Comparator<Line> {
+
+		@Override
+		public int compare(Line o1, Line o2) {
+			return o1.start - o2.start;
+		}
+
+	}
+
+	public static void main(String[] args) {
+
+		Line l1 = new Line(4, 9);
+		Line l2 = new Line(1, 4);
+		Line l3 = new Line(7, 15);
+		Line l4 = new Line(2, 4);
+		Line l5 = new Line(4, 6);
+		Line l6 = new Line(3, 7);
+
+		// 底层堆结构，heap
+		PriorityQueue<Line> heap = new PriorityQueue<>(new StartComparator());
+		heap.add(l1);
+		heap.add(l2);
+		heap.add(l3);
+		heap.add(l4);
+		heap.add(l5);
+		heap.add(l6);
+
+		while (!heap.isEmpty()) {
+			Line cur = heap.poll();
+			System.out.println(cur.start + "," + cur.end);
+		}
+
+		System.out.println("test begin");
+		int N = 100;
+		int L = 0;
+		int R = 200;
+		int testTimes = 200000;
+		for (int i = 0; i < testTimes; i++) {
+			int[][] lines = generateLines(N, L, R);
+			int ans1 = maxCover1(lines);
+			int ans2 = maxCover2(lines);
+			int ans3 = maxCover3(lines);
+			if (ans1 != ans2 || ans1 != ans3) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("test end");
+	}
+
+}

src/class07/Code02_EveryStepShowBoss.java

@@ -0,0 +1,303 @@
+package class07;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+
+public class Code02_EveryStepShowBoss {
+
+	public static class Customer {
+		public int id;
+		public int buy;
+		public int enterTime;
+
+		public Customer(int v, int b, int o) {
+			id = v;
+			buy = b;
+			enterTime = 0;
+		}
+	}
+
+	public static class CandidateComparator implements Comparator<Customer> {
+
+		@Override
+		public int compare(Customer o1, Customer o2) {
+			return o1.buy != o2.buy ? (o2.buy - o1.buy) : (o1.enterTime - o2.enterTime);
+		}
+
+	}
+
+	public static class DaddyComparator implements Comparator<Customer> {
+
+		@Override
+		public int compare(Customer o1, Customer o2) {
+			return o1.buy != o2.buy ? (o1.buy - o2.buy) : (o1.enterTime - o2.enterTime);
+		}
+
+	}
+
+	public static class WhosYourDaddy {
+		private HashMap<Integer, Customer> customers;
+		private HeapGreater<Customer> candHeap;
+		private HeapGreater<Customer> daddyHeap;
+		private final int daddyLimit;
+
+		public WhosYourDaddy(int limit) {
+			customers = new HashMap<Integer, Customer>();
+			candHeap = new HeapGreater<>(new CandidateComparator());
+			daddyHeap = new HeapGreater<>(new DaddyComparator());
+			daddyLimit = limit;
+		}
+
+		// 当前处理i号事件，arr[i] -> id,  buyOrRefund
+		public void operate(int time, int id, boolean buyOrRefund) {
+			if (!buyOrRefund && !customers.containsKey(id)) {
+				return;
+			}
+			if (!customers.containsKey(id)) {
+				customers.put(id, new Customer(id, 0, 0));
+			}
+			Customer c = customers.get(id);
+			if (buyOrRefund) {
+				c.buy++;
+			} else {
+				c.buy--;
+			}
+			if (c.buy == 0) {
+				customers.remove(id);
+			}
+			if (!candHeap.contains(c) && !daddyHeap.contains(c)) {
+				if (daddyHeap.size() < daddyLimit) {
+					c.enterTime = time;
+					daddyHeap.push(c);
+				} else {
+					c.enterTime = time;
+					candHeap.push(c);
+				}
+			} else if (candHeap.contains(c)) {
+				if (c.buy == 0) {
+					candHeap.remove(c);
+				} else {
+					candHeap.resign(c);
+				}
+			} else {
+				if (c.buy == 0) {
+					daddyHeap.remove(c);
+				} else {
+					daddyHeap.resign(c);
+				}
+			}
+			daddyMove(time);
+		}
+
+		public List<Integer> getDaddies() {
+			List<Customer> customers = daddyHeap.getAllElements();
+			List<Integer> ans = new ArrayList<>();
+			for (Customer c : customers) {
+				ans.add(c.id);
+			}
+			return ans;
+		}
+
+		private void daddyMove(int time) {
+			if (candHeap.isEmpty()) {
+				return;
+			}
+			if (daddyHeap.size() < daddyLimit) {
+				Customer p = candHeap.pop();
+				p.enterTime = time;
+				daddyHeap.push(p);
+			} else {
+				if (candHeap.peek().buy > daddyHeap.peek().buy) {
+					Customer oldDaddy = daddyHeap.pop();
+					Customer newDaddy = candHeap.pop();
+					oldDaddy.enterTime = time;
+					newDaddy.enterTime = time;
+					daddyHeap.push(newDaddy);
+					candHeap.push(oldDaddy);
+				}
+			}
+		}
+
+	}
+
+	public static List<List<Integer>> topK(int[] arr, boolean[] op, int k) {
+		List<List<Integer>> ans = new ArrayList<>();
+		WhosYourDaddy whoDaddies = new WhosYourDaddy(k);
+		for (int i = 0; i < arr.length; i++) {
+			whoDaddies.operate(i, arr[i], op[i]);
+			ans.add(whoDaddies.getDaddies());
+		}
+		return ans;
+	}
+
+	// 干完所有的事，模拟，不优化
+	public static List<List<Integer>> compare(int[] arr, boolean[] op, int k) {
+		HashMap<Integer, Customer> map = new HashMap<>();
+		ArrayList<Customer> cands = new ArrayList<>();
+		ArrayList<Customer> daddy = new ArrayList<>();
+		List<List<Integer>> ans = new ArrayList<>();
+		for (int i = 0; i < arr.length; i++) {
+			int id = arr[i];
+			boolean buyOrRefund = op[i];
+			if (!buyOrRefund && !map.containsKey(id)) {
+				ans.add(getCurAns(daddy));
+				continue;
+			}
+			// 没有发生：用户购买数为0并且又退货了
+			// 用户之前购买数是0，此时买货事件
+			// 用户之前购买数>0， 此时买货
+			// 用户之前购买数>0, 此时退货
+			if (!map.containsKey(id)) {
+				map.put(id, new Customer(id, 0, 0));
+			}
+			// 买、卖
+			Customer c = map.get(id);
+			if (buyOrRefund) {
+				c.buy++;
+			} else {
+				c.buy--;
+			}
+			if (c.buy == 0) {
+				map.remove(id);
+			}
+			// c
+			// 下面做
+			if (!cands.contains(c) && !daddy.contains(c)) {
+				if (daddy.size() < k) {
+					c.enterTime = i;
+					daddy.add(c);
+				} else {
+					c.enterTime = i;
+					cands.add(c);
+				}
+			}
+			cleanZeroBuy(cands);
+			cleanZeroBuy(daddy);
+			cands.sort(new CandidateComparator());
+			daddy.sort(new DaddyComparator());
+			move(cands, daddy, k, i);
+			ans.add(getCurAns(daddy));
+		}
+		return ans;
+	}
+
+	public static void move(ArrayList<Customer> cands, ArrayList<Customer> daddy, int k, int time) {
+		if (cands.isEmpty()) {
+			return;
+		}
+		// 候选区不为空
+		if (daddy.size() < k) {
+			Customer c = cands.get(0);
+			c.enterTime = time;
+			daddy.add(c);
+			cands.remove(0);
+		} else { // 等奖区满了，候选区有东西
+			if (cands.get(0).buy > daddy.get(0).buy) {
+				Customer oldDaddy = daddy.get(0);
+				daddy.remove(0);
+				Customer newDaddy = cands.get(0);
+				cands.remove(0);
+				newDaddy.enterTime = time;
+				oldDaddy.enterTime = time;
+				daddy.add(newDaddy);
+				cands.add(oldDaddy);
+			}
+		}
+	}
+
+	public static void cleanZeroBuy(ArrayList<Customer> arr) {
+		List<Customer> noZero = new ArrayList<Customer>();
+		for (Customer c : arr) {
+			if (c.buy != 0) {
+				noZero.add(c);
+			}
+		}
+		arr.clear();
+		for (Customer c : noZero) {
+			arr.add(c);
+		}
+	}
+
+	public static List<Integer> getCurAns(ArrayList<Customer> daddy) {
+		List<Integer> ans = new ArrayList<>();
+		for (Customer c : daddy) {
+			ans.add(c.id);
+		}
+		return ans;
+	}
+
+	// 为了测试
+	public static class Data {
+		public int[] arr;
+		public boolean[] op;
+
+		public Data(int[] a, boolean[] o) {
+			arr = a;
+			op = o;
+		}
+	}
+
+	// 为了测试
+	public static Data randomData(int maxValue, int maxLen) {
+		int len = (int) (Math.random() * maxLen) + 1;
+		int[] arr = new int[len];
+		boolean[] op = new boolean[len];
+		for (int i = 0; i < len; i++) {
+			arr[i] = (int) (Math.random() * maxValue);
+			op[i] = Math.random() < 0.5 ? true : false;
+		}
+		return new Data(arr, op);
+	}
+
+	// 为了测试
+	public static boolean sameAnswer(List<List<Integer>> ans1, List<List<Integer>> ans2) {
+		if (ans1.size() != ans2.size()) {
+			return false;
+		}
+		for (int i = 0; i < ans1.size(); i++) {
+			List<Integer> cur1 = ans1.get(i);
+			List<Integer> cur2 = ans2.get(i);
+			if (cur1.size() != cur2.size()) {
+				return false;
+			}
+			cur1.sort((a, b) -> a - b);
+			cur2.sort((a, b) -> a - b);
+			for (int j = 0; j < cur1.size(); j++) {
+				if (!cur1.get(j).equals(cur2.get(j))) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) {
+		int maxValue = 10;
+		int maxLen = 100;
+		int maxK = 6;
+		int testTimes = 100000;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTimes; i++) {
+			Data testData = randomData(maxValue, maxLen);
+			int k = (int) (Math.random() * maxK) + 1;
+			int[] arr = testData.arr;
+			boolean[] op = testData.op;
+			List<List<Integer>> ans1 = topK(arr, op, k);
+			List<List<Integer>> ans2 = compare(arr, op, k);
+			if (!sameAnswer(ans1, ans2)) {
+				for (int j = 0; j < arr.length; j++) {
+					System.out.println(arr[j] + " , " + op[j]);
+				}
+				System.out.println(k);
+				System.out.println(ans1);
+				System.out.println(ans2);
+				System.out.println("出错了！");
+				break;
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class07/HeapGreater.java

@@ -0,0 +1,112 @@
+package class07;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+
+/*
+ * T一定要是非基础类型，有基础类型需求包一层
+ */
+public class HeapGreater<T> {
+
+	private ArrayList<T> heap;
+	private HashMap<T, Integer> indexMap;
+	private int heapSize;
+	private Comparator<? super T> comp;
+
+	public HeapGreater(Comparator<T> c) {
+		heap = new ArrayList<>();
+		indexMap = new HashMap<>();
+		heapSize = 0;
+		comp = c;
+	}
+
+	public boolean isEmpty() {
+		return heapSize == 0;
+	}
+
+	public int size() {
+		return heapSize;
+	}
+
+	public boolean contains(T obj) {
+		return indexMap.containsKey(obj);
+	}
+
+	public T peek() {
+		return heap.get(0);
+	}
+
+	public void push(T obj) {
+		heap.add(obj);
+		indexMap.put(obj, heapSize);
+		heapInsert(heapSize++);
+	}
+
+	public T pop() {
+		T ans = heap.get(0);
+		swap(0, heapSize - 1);
+		indexMap.remove(ans);
+		heap.remove(--heapSize);
+		heapify(0);
+		return ans;
+	}
+
+	public void remove(T obj) {
+		T replace = heap.get(heapSize - 1);
+		int index = indexMap.get(obj);
+		indexMap.remove(obj);
+		heap.remove(--heapSize);
+		if (obj != replace) {
+			heap.set(index, replace);
+			indexMap.put(replace, index);
+			resign(replace);
+		}
+	}
+
+	public void resign(T obj) {
+		heapInsert(indexMap.get(obj));
+		heapify(indexMap.get(obj));
+	}
+
+	// 请返回堆上的所有元素
+	public List<T> getAllElements() {
+		List<T> ans = new ArrayList<>();
+		for (T c : heap) {
+			ans.add(c);
+		}
+		return ans;
+	}
+
+	private void heapInsert(int index) {
+		while (comp.compare(heap.get(index), heap.get((index - 1) / 2)) < 0) {
+			swap(index, (index - 1) / 2);
+			index = (index - 1) / 2;
+		}
+	}
+
+	private void heapify(int index) {
+		int left = index * 2 + 1;
+		while (left < heapSize) {
+			int best = left + 1 < heapSize && comp.compare(heap.get(left + 1), heap.get(left)) < 0 ? (left + 1) : left;
+			best = comp.compare(heap.get(best), heap.get(index)) < 0 ? best : index;
+			if (best == index) {
+				break;
+			}
+			swap(best, index);
+			index = best;
+			left = index * 2 + 1;
+		}
+	}
+
+	private void swap(int i, int j) {
+		T o1 = heap.get(i);
+		T o2 = heap.get(j);
+		heap.set(i, o2);
+		heap.set(j, o1);
+		indexMap.put(o2, i);
+		indexMap.put(o1, j);
+	}
+
+}

src/class07/Inner.java

@@ -0,0 +1,9 @@
+package class07;
+
+public class Inner<T> {
+	public T value;
+
+	public Inner(T v) {
+		value = v;
+	}
+}

src/class08/Code01_TrieTree.java

@@ -0,0 +1,299 @@
+package class08;
+
+import java.util.HashMap;
+
+// 该程序的对数器跑不过，你能发现bug在哪吗？
+public class Code01_TrieTree {
+
+	// 前缀树节点类型
+	public static class Node1 {
+		public int pass;
+		public int end;
+		public Node1[] nexts;
+
+		public Node1() {
+			pass = 0;
+			end = 0;
+			nexts = new Node1[26];
+		}
+	}
+
+	public static class Trie1 {
+		private Node1 root;
+
+		public Trie1() {
+			root = new Node1();
+		}
+
+		public void insert(String word) {
+			if (word == null) {
+				return;
+			}
+			char[] chs = word.toCharArray();
+			Node1 node = root;
+			node.pass++;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) { // 从左往右遍历字符
+				index = chs[i] - 'a'; // 由字符，对应成走向哪条路
+				if (node.nexts[index] == null) {
+					node.nexts[index] = new Node1();
+				}
+				node = node.nexts[index];
+				node.pass++;
+			}
+			node.end++;
+		}
+
+		public void delete(String word) {
+			if (search(word) != 0) {
+				char[] chs = word.toCharArray();
+				Node1 node = root;
+				node.pass--;
+				int index = 0;
+				for (int i = 0; i < chs.length; i++) {
+					index = chs[i] - 'a';
+					if (--node.nexts[index].pass == 0) {
+						node.nexts[index] = null;
+						return;
+					}
+					node = node.nexts[index];
+				}
+				node.end--;
+			}
+		}
+
+		// word这个单词之前加入过几次
+		public int search(String word) {
+			if (word == null) {
+				return 0;
+			}
+			char[] chs = word.toCharArray();
+			Node1 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = chs[i] - 'a';
+				if (node.nexts[index] == null) {
+					return 0;
+				}
+				node = node.nexts[index];
+			}
+			return node.end;
+		}
+
+		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
+		public int prefixNumber(String pre) {
+			if (pre == null) {
+				return 0;
+			}
+			char[] chs = pre.toCharArray();
+			Node1 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = chs[i] - 'a';
+				if (node.nexts[index] == null) {
+					return 0;
+				}
+				node = node.nexts[index];
+			}
+			return node.pass;
+		}
+	}
+
+	public static class Node2 {
+		public int pass;
+		public int end;
+		public HashMap<Integer, Node2> nexts;
+
+		public Node2() {
+			pass = 0;
+			end = 0;
+			nexts = new HashMap<>();
+		}
+	}
+
+	public static class Trie2 {
+		private Node2 root;
+
+		public Trie2() {
+			root = new Node2();
+		}
+
+		public void insert(String word) {
+			if (word == null) {
+				return;
+			}
+			char[] chs = word.toCharArray();
+			Node2 node = root;
+			node.pass++;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					node.nexts.put(index, new Node2());
+				}
+				node = node.nexts.get(index);
+				node.pass++;
+			}
+			node.end++;
+		}
+
+		public void delete(String word) {
+			if (search(word) != 0) {
+				char[] chs = word.toCharArray();
+				Node2 node = root;
+				node.pass--;
+				int index = 0;
+				for (int i = 0; i < chs.length; i++) {
+					index = (int) chs[i];
+					if (--node.nexts.get(index).pass == 0) {
+						node.nexts.remove(index);
+						return;
+					}
+					node = node.nexts.get(index);
+				}
+				node.end--;
+			}
+		}
+
+		// word这个单词之前加入过几次
+		public int search(String word) {
+			if (word == null) {
+				return 0;
+			}
+			char[] chs = word.toCharArray();
+			Node2 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					return 0;
+				}
+				node = node.nexts.get(index);
+			}
+			return node.end;
+		}
+
+		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
+		public int prefixNumber(String pre) {
+			if (pre == null) {
+				return 0;
+			}
+			char[] chs = pre.toCharArray();
+			Node2 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					return 0;
+				}
+				node = node.nexts.get(index);
+			}
+			return node.pass;
+		}
+	}
+
+	public static class Right {
+
+		private HashMap<String, Integer> box;
+
+		public Right() {
+			box = new HashMap<>();
+		}
+
+		public void insert(String word) {
+			if (!box.containsKey(word)) {
+				box.put(word, 1);
+			} else {
+				box.put(word, box.get(word) + 1);
+			}
+		}
+
+		public void delete(String word) {
+			if (box.containsKey(word)) {
+				if (box.get(word) == 1) {
+					box.remove(word);
+				} else {
+					box.put(word, box.get(word) - 1);
+				}
+			}
+		}
+
+		public int search(String word) {
+			if (!box.containsKey(word)) {
+				return 0;
+			} else {
+				return box.get(word);
+			}
+		}
+
+		public int prefixNumber(String pre) {
+			int count = 0;
+			for (String cur : box.keySet()) {
+				if (cur.startsWith(pre)) {
+					count++;
+				}
+			}
+			return count;
+		}
+	}
+
+	// for test
+	public static String generateRandomString(int strLen) {
+		char[] ans = new char[(int) (Math.random() * strLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			int value = (int) (Math.random() * 6);
+			ans[i] = (char) (97 + value);
+		}
+		return String.valueOf(ans);
+	}
+
+	// for test
+	public static String[] generateRandomStringArray(int arrLen, int strLen) {
+		String[] ans = new String[(int) (Math.random() * arrLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			ans[i] = generateRandomString(strLen);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		int arrLen = 100;
+		int strLen = 20;
+		int testTimes = 100000;
+		for (int i = 0; i < testTimes; i++) {
+			String[] arr = generateRandomStringArray(arrLen, strLen);
+			Trie1 trie1 = new Trie1();
+			Trie2 trie2 = new Trie2();
+			Right right = new Right();
+			for (int j = 0; j < arr.length; j++) {
+				double decide = Math.random();
+				if (decide < 0.25) {
+					trie1.insert(arr[j]);
+					trie2.insert(arr[j]);
+					right.insert(arr[j]);
+				} else if (decide < 0.5) {
+					trie1.delete(arr[j]);
+					trie2.delete(arr[j]);
+					right.delete(arr[j]);
+				} else if (decide < 0.75) {
+					int ans1 = trie1.search(arr[j]);
+					int ans2 = trie2.search(arr[j]);
+					int ans3 = right.search(arr[j]);
+					if (ans1 != ans2 || ans2 != ans3) {
+						System.out.println("Oops!");
+					}
+				} else {
+					int ans1 = trie1.prefixNumber(arr[j]);
+					int ans2 = trie2.prefixNumber(arr[j]);
+					int ans3 = right.prefixNumber(arr[j]);
+					if (ans1 != ans2 || ans2 != ans3) {
+						System.out.println("Oops!");
+					}
+				}
+			}
+		}
+		System.out.println("finish!");
+
+	}
+
+}

src/class08/Code02_TrieTree.java

@@ -0,0 +1,314 @@
+package class08;
+
+import java.util.HashMap;
+
+// 该程序完全正确
+public class Code02_TrieTree {
+
+	public static class Node1 {
+		public int pass;
+		public int end;
+		public Node1[] nexts;//用一个固定长度的数组来表示通往下级的路
+
+		// char tmp = 'b'  (tmp - 'a')
+		public Node1() {
+			pass = 0;
+			end = 0;
+			//如果你只要加入小写的26个字母，那么你最多只需要26条路就行了。这个路其实就是一个指针。利用null来标记路存不存在
+			// 0    a
+			// 1    b
+			// 2    c
+			// ..   ..
+			// 25   z
+			// nexts[i] == null   i方向的路不存在
+			// nexts[i] != null   i方向的路存在
+			nexts = new Node1[26];
+		}
+	}
+
+	public static class Trie1 {
+		private Node1 root;//只留了一个头节点，一定能够通过头节点找到所有的结点。
+
+		public Trie1() {
+			root = new Node1();
+		}
+
+		public void insert(String word) {
+			if (word == null) {
+				return;
+			}
+			char[] str = word.toCharArray();
+			Node1 node = root;
+			node.pass++;
+			int path = 0;
+			for (int i = 0; i < str.length; i++) { // 从左往右遍历字符
+				path = str[i] - 'a'; // 由字符，对应成走向哪条路
+				if (node.nexts[path] == null) {
+					node.nexts[path] = new Node1();
+				}
+				node = node.nexts[path];
+				node.pass++;
+			}
+			node.end++;
+
+		}
+
+		/**
+		 * 如果到某一个地方pass为0了，那么说明后面的pass值一定都为0.因为pass为0说明只有一个字符串会走这条路，
+		 * 而现在这个字符串你要删掉，那么只需要把后面的路彻底放弃就行了。也就是pass=0给了我们额外信息。
+		 * @param word
+		 */
+		public void delete(String word) {
+			if (search(word) != 0) {
+				char[] chs = word.toCharArray();
+				Node1 node = root;
+				node.pass--;
+				int path = 0;
+				for (int i = 0; i < chs.length; i++) {
+					path = chs[i] - 'a';
+					if (--node.nexts[path].pass == 0) {
+						node.nexts[path] = null;
+						return;
+					}
+					node = node.nexts[path];
+				}
+				node.end--;
+			}
+		}
+
+		// word这个单词之前加入过几次
+		public int search(String word) {
+			if (word == null) {
+				return 0;
+			}
+			char[] chs = word.toCharArray();
+			Node1 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = chs[i] - 'a';
+				if (node.nexts[index] == null) {
+					return 0;
+				}
+				node = node.nexts[index];
+			}
+			return node.end;
+		}
+
+		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
+		public int prefixNumber(String pre) {
+			if (pre == null) {
+				return 0;
+			}
+			char[] chs = pre.toCharArray();
+			Node1 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = chs[i] - 'a';
+				if (node.nexts[index] == null) {
+					return 0;
+				}
+				node = node.nexts[index];
+			}
+			return node.pass;
+		}
+
+	}
+
+	public static class Node2 {
+		public int pass;
+		public int end;
+		public HashMap<Integer, Node2> nexts;//26个大小的空间不够就用这个，Integer表示这条路的ASCII码值
+
+		public Node2() {
+			pass = 0;
+			end = 0;
+			nexts = new HashMap<>();
+		}
+	}
+
+	public static class Trie2 {
+		private Node2 root;
+
+		public Trie2() {
+			root = new Node2();
+		}
+
+		public void insert(String word) {
+			if (word == null) {
+				return;
+			}
+			char[] chs = word.toCharArray();
+			Node2 node = root;
+			node.pass++;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					node.nexts.put(index, new Node2());
+				}
+				node = node.nexts.get(index);
+				node.pass++;
+			}
+			node.end++;
+		}
+
+		public void delete(String word) {
+			if (search(word) != 0) {
+				char[] chs = word.toCharArray();
+				Node2 node = root;
+				node.pass--;
+				int index = 0;
+				for (int i = 0; i < chs.length; i++) {
+					index = (int) chs[i];
+					if (--node.nexts.get(index).pass == 0) {
+						node.nexts.remove(index);
+						return;
+					}
+					node = node.nexts.get(index);
+				}
+				node.end--;
+			}
+		}
+
+		// word这个单词之前加入过几次
+		public int search(String word) {
+			if (word == null) {
+				return 0;
+			}
+			char[] chs = word.toCharArray();
+			Node2 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					return 0;
+				}
+				node = node.nexts.get(index);
+			}
+			return node.end;
+		}
+
+		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
+		public int prefixNumber(String pre) {
+			if (pre == null) {
+				return 0;
+			}
+			char[] chs = pre.toCharArray();
+			Node2 node = root;
+			int index = 0;
+			for (int i = 0; i < chs.length; i++) {
+				index = (int) chs[i];
+				if (!node.nexts.containsKey(index)) {
+					return 0;
+				}
+				node = node.nexts.get(index);
+			}
+			return node.pass;
+		}
+	}
+
+	public static class Right {
+
+		private HashMap<String, Integer> box;
+
+		public Right() {
+			box = new HashMap<>();
+		}
+
+		public void insert(String word) {
+			if (!box.containsKey(word)) {
+				box.put(word, 1);
+			} else {
+				box.put(word, box.get(word) + 1);
+			}
+		}
+
+		public void delete(String word) {
+			if (box.containsKey(word)) {
+				if (box.get(word) == 1) {
+					box.remove(word);
+				} else {
+					box.put(word, box.get(word) - 1);
+				}
+			}
+		}
+
+		public int search(String word) {
+			if (!box.containsKey(word)) {
+				return 0;
+			} else {
+				return box.get(word);
+			}
+		}
+
+		public int prefixNumber(String pre) {
+			int count = 0;
+			for (String cur : box.keySet()) {
+				if (cur.startsWith(pre)) {
+					count += box.get(cur);
+				}
+			}
+			return count;
+		}
+	}
+
+	// for test
+	public static String generateRandomString(int strLen) {
+		char[] ans = new char[(int) (Math.random() * strLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			int value = (int) (Math.random() * 6);
+			ans[i] = (char) (97 + value);
+		}
+		return String.valueOf(ans);
+	}
+
+	// for test
+	public static String[] generateRandomStringArray(int arrLen, int strLen) {
+		String[] ans = new String[(int) (Math.random() * arrLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			ans[i] = generateRandomString(strLen);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		int arrLen = 100;
+		int strLen = 20;
+		int testTimes = 100000;
+		for (int i = 0; i < testTimes; i++) {
+			String[] arr = generateRandomStringArray(arrLen, strLen);
+			Trie1 trie1 = new Trie1();
+			Trie2 trie2 = new Trie2();
+			Right right = new Right();
+			for (int j = 0; j < arr.length; j++) {
+				double decide = Math.random();
+				if (decide < 0.25) {
+					trie1.insert(arr[j]);
+					trie2.insert(arr[j]);
+					right.insert(arr[j]);
+				} else if (decide < 0.5) {
+					trie1.delete(arr[j]);
+					trie2.delete(arr[j]);
+					right.delete(arr[j]);
+				} else if (decide < 0.75) {
+					int ans1 = trie1.search(arr[j]);
+					int ans2 = trie2.search(arr[j]);
+					int ans3 = right.search(arr[j]);
+					if (ans1 != ans2 || ans2 != ans3) {
+						System.out.println("Oops!");
+					}
+				} else {
+					int ans1 = trie1.prefixNumber(arr[j]);
+					int ans2 = trie2.prefixNumber(arr[j]);
+					int ans3 = right.prefixNumber(arr[j]);
+					if (ans1 != ans2 || ans2 != ans3) {
+						System.out.println("Oops!");
+					}
+				}
+			}
+		}
+		System.out.println("finish!");
+
+	}
+
+}

src/class08/Code03_CountSort.java

@@ -0,0 +1,111 @@
+package class08;
+
+import java.util.Arrays;
+
+public class Code03_CountSort {
+
+	// only for 0~200 value
+	public static void countSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		int max = Integer.MIN_VALUE;
+		for (int i = 0; i < arr.length; i++) {
+			max = Math.max(max, arr[i]);
+		}
+		int[] bucket = new int[max + 1];
+		for (int i = 0; i < arr.length; i++) {
+			bucket[arr[i]]++;
+		}
+		int i = 0;
+		for (int j = 0; j < bucket.length; j++) {
+			while (bucket[j]-- > 0) {
+				arr[i++] = j;
+			}
+		}
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// 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());
+		}
+		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 = 150;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			countSort(arr1);
+			comparator(arr2);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		countSort(arr);
+		printArray(arr);
+
+	}
+
+}

src/class08/Code04_RadixSort.java

@@ -0,0 +1,148 @@
+package class08;
+
+import java.util.Arrays;
+
+public class Code04_RadixSort {
+
+	// only for no-negative value
+	public static void radixSort(int[] arr) {
+		if (arr == null || arr.length < 2) {
+			return;
+		}
+		radixSort(arr, 0, arr.length - 1, maxbits(arr));
+	}
+
+	public static int maxbits(int[] arr) {
+		int max = Integer.MIN_VALUE;
+		for (int i = 0; i < arr.length; i++) {
+			max = Math.max(max, arr[i]);
+		}
+		int res = 0;
+		while (max != 0) {
+			res++;
+			max /= 10;
+		}
+		return res;
+	}
+
+	// arr[L..R]排序  ,  最大值的十进制位数digit
+	public static void radixSort(int[] arr, int L, int R, int digit) {
+		final int radix = 10;
+		int i = 0, j = 0;
+		// 有多少个数准备多少个辅助空间
+		int[] help = new int[R - L + 1];
+		for (int d = 1; d <= digit; d++) { // 有多少位就进出几次
+			// 10个空间
+		    // count[0] 当前位(d位)是0的数字有多少个
+			// count[1] 当前位(d位)是(0和1)的数字有多少个
+			// count[2] 当前位(d位)是(0、1和2)的数字有多少个
+			// count[i] 当前位(d位)是(0~i)的数字有多少个
+			int[] count = new int[radix]; // count[0..9]
+			for (i = L; i <= R; i++) {
+				// 103  1   3
+				// 209  1   9
+				j = getDigit(arr[i], d);
+				count[j]++;
+			}
+			for (i = 1; i < radix; i++) {
+				count[i] = count[i] + count[i - 1];
+			}
+			for (i = R; i >= L; i--) {
+				j = getDigit(arr[i], d);
+				help[count[j] - 1] = arr[i];
+				count[j]--;
+			}
+			for (i = L, j = 0; i <= R; i++, j++) {
+				arr[i] = help[j];
+			}
+		}
+	}
+
+	public static int getDigit(int x, int d) {
+		return ((x / ((int) Math.pow(10, d - 1))) % 10);
+	}
+
+	// for test
+	public static void comparator(int[] arr) {
+		Arrays.sort(arr);
+	}
+
+	// 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());
+		}
+		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 = 100000;
+		boolean succeed = true;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr1 = generateRandomArray(maxSize, maxValue);
+			int[] arr2 = copyArray(arr1);
+			radixSort(arr1);
+			comparator(arr2);
+			if (!isEqual(arr1, arr2)) {
+				succeed = false;
+				printArray(arr1);
+				printArray(arr2);
+				break;
+			}
+		}
+		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
+
+		int[] arr = generateRandomArray(maxSize, maxValue);
+		printArray(arr);
+		radixSort(arr);
+		printArray(arr);
+
+	}
+
+}

src/class09/Code01_LinkedListMid.java

@@ -0,0 +1,164 @@
+package class09;
+
+import java.util.ArrayList;
+
+public class Code01_LinkedListMid {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int v) {
+			value = v;
+		}
+	}
+
+	// head 头。1)输入链表头节点，奇数长度返回中点，偶数长度返回上中点
+	public static Node midOrUpMidNode(Node head) {
+		if (head == null || head.next == null || head.next.next == null) {
+			return head;
+		}
+		// 链表有3个点或以上
+		Node slow = head.next;
+		Node fast = head.next.next;
+		while (fast.next != null && fast.next.next != null) {
+			slow = slow.next;
+			fast = fast.next.next;
+		}
+		return slow;
+	}
+	//2)输入链表头节点,奇数长度返回中点，偶数长度返回下中点
+	public static Node midOrDownMidNode(Node head) {
+		if (head == null || head.next == null) {
+			return head;
+		}
+		Node slow = head.next;
+		Node fast = head.next;
+		while (fast.next != null && fast.next.next != null) {
+			slow = slow.next;
+			fast = fast.next.next;
+		}
+		return slow;
+	}
+
+	//3）输入链表头节点，奇数长度返回中点前一个，偶数长度返回上中点前一个
+	public static Node midOrUpMidPreNode(Node head) {
+		if (head == null || head.next == null || head.next.next == null) {
+			return null;
+		}
+		Node slow = head;
+		Node fast = head.next.next;
+		while (fast.next != null && fast.next.next != null) {
+			slow = slow.next;
+			fast = fast.next.next;
+		}
+		return slow;
+	}
+
+	//4）输入链表头节点，奇数长度返回中点前一个，偶数长度返回下中点前一个
+	public static Node midOrDownMidPreNode(Node head) {
+		if (head == null || head.next == null) {
+			return null;
+		}
+		if (head.next.next == null) {
+			return head;
+		}
+		Node slow = head;
+		Node fast = head.next;
+		while (fast.next != null && fast.next.next != null) {
+			slow = slow.next;
+			fast = fast.next.next;
+		}
+		return slow;
+	}
+
+	public static Node right1(Node head) {
+		if (head == null) {
+			return null;
+		}
+		Node cur = head;
+		ArrayList<Node> arr = new ArrayList<>();
+		while (cur != null) {
+			arr.add(cur);
+			cur = cur.next;
+		}
+		return arr.get((arr.size() - 1) / 2);
+	}
+
+	public static Node right2(Node head) {
+		if (head == null) {
+			return null;
+		}
+		Node cur = head;
+		ArrayList<Node> arr = new ArrayList<>();
+		while (cur != null) {
+			arr.add(cur);
+			cur = cur.next;
+		}
+		return arr.get(arr.size() / 2);
+	}
+
+	public static Node right3(Node head) {
+		if (head == null || head.next == null || head.next.next == null) {
+			return null;
+		}
+		Node cur = head;
+		ArrayList<Node> arr = new ArrayList<>();
+		while (cur != null) {
+			arr.add(cur);
+			cur = cur.next;
+		}
+		return arr.get((arr.size() - 3) / 2);
+	}
+
+	public static Node right4(Node head) {
+		if (head == null || head.next == null) {
+			return null;
+		}
+		Node cur = head;
+		ArrayList<Node> arr = new ArrayList<>();
+		while (cur != null) {
+			arr.add(cur);
+			cur = cur.next;
+		}
+		return arr.get((arr.size() - 2) / 2);
+	}
+
+	public static void main(String[] args) {
+		Node test = null;
+		test = new Node(0);
+		test.next = new Node(1);
+		test.next.next = new Node(2);
+		test.next.next.next = new Node(3);
+		test.next.next.next.next = new Node(4);
+		test.next.next.next.next.next = new Node(5);
+		test.next.next.next.next.next.next = new Node(6);
+		test.next.next.next.next.next.next.next = new Node(7);
+		test.next.next.next.next.next.next.next.next = new Node(8);
+
+		Node ans1 = null;
+		Node ans2 = null;
+
+		ans1 = midOrUpMidNode(test);
+		ans2 = right1(test);
+		System.out.println(ans1 != null ? ans1.value : "无");
+		System.out.println(ans2 != null ? ans2.value : "无");
+
+		ans1 = midOrDownMidNode(test);
+		ans2 = right2(test);
+		System.out.println(ans1 != null ? ans1.value : "无");
+		System.out.println(ans2 != null ? ans2.value : "无");
+
+		ans1 = midOrUpMidPreNode(test);
+		ans2 = right3(test);
+		System.out.println(ans1 != null ? ans1.value : "无");
+		System.out.println(ans2 != null ? ans2.value : "无");
+
+		ans1 = midOrDownMidPreNode(test);
+		ans2 = right4(test);
+		System.out.println(ans1 != null ? ans1.value : "无");
+		System.out.println(ans2 != null ? ans2.value : "无");
+
+	}
+
+}

src/class09/Code02_IsPalindromeList.java

@@ -0,0 +1,204 @@
+package class09;
+
+import java.util.Stack;
+
+public class Code02_IsPalindromeList {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	// need n extra space
+	public static boolean isPalindrome1(Node head) {
+		Stack<Node> stack = new Stack<Node>();
+		Node cur = head;
+		while (cur != null) {
+			stack.push(cur);
+			cur = cur.next;
+		}
+		while (head != null) {
+			if (head.value != stack.pop().value) {
+				return false;
+			}
+			head = head.next;
+		}
+		return true;
+	}
+
+	// need n/2 extra space
+	public static boolean isPalindrome2(Node head) {
+		if (head == null || head.next == null) {
+			return true;
+		}
+		Node right = head.next;
+		Node cur = head;
+		while (cur.next != null && cur.next.next != null) {
+			right = right.next;
+			cur = cur.next.next;
+		}
+		Stack<Node> stack = new Stack<Node>();
+		while (right != null) {
+			stack.push(right);
+			right = right.next;
+		}
+		while (!stack.isEmpty()) {
+			if (head.value != stack.pop().value) {
+				return false;
+			}
+			head = head.next;
+		}
+		return true;
+	}
+
+	// need O(1) extra space
+	public static boolean isPalindrome3(Node head) {
+		if (head == null || head.next == null) {
+			return true;
+		}
+		Node n1 = head;
+		Node n2 = head;
+		while (n2.next != null && n2.next.next != null) { // find mid node
+			n1 = n1.next; // n1 -> mid
+			n2 = n2.next.next; // n2 -> end
+		}
+		// n1 中点
+		
+		
+		n2 = n1.next; // n2 -> right part first node
+		n1.next = null; // mid.next -> null
+		Node n3 = null;
+		while (n2 != null) { // right part convert
+			n3 = n2.next; // n3 -> save next node
+			n2.next = n1; // next of right node convert
+			n1 = n2; // n1 move
+			n2 = n3; // n2 move
+		}
+		n3 = n1; // n3 -> save last node
+		n2 = head;// n2 -> left first node
+		boolean res = true;
+		while (n1 != null && n2 != null) { // check palindrome
+			if (n1.value != n2.value) {
+				res = false;
+				break;
+			}
+			n1 = n1.next; // left to mid
+			n2 = n2.next; // right to mid
+		}
+		n1 = n3.next;
+		n3.next = null;
+		while (n1 != null) { // recover list
+			n2 = n1.next;
+			n1.next = n3;
+			n3 = n1;
+			n1 = n2;
+		}
+		return res;
+	}
+
+	public static void printLinkedList(Node node) {
+		System.out.print("Linked List: ");
+		while (node != null) {
+			System.out.print(node.value + " ");
+			node = node.next;
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+
+		Node head = null;
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		head.next.next = new Node(3);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		head.next.next = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		head.next.next = new Node(3);
+		head.next.next.next = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		head.next.next = new Node(2);
+		head.next.next.next = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+		head = new Node(1);
+		head.next = new Node(2);
+		head.next.next = new Node(3);
+		head.next.next.next = new Node(2);
+		head.next.next.next.next = new Node(1);
+		printLinkedList(head);
+		System.out.print(isPalindrome1(head) + " | ");
+		System.out.print(isPalindrome2(head) + " | ");
+		System.out.println(isPalindrome3(head) + " | ");
+		printLinkedList(head);
+		System.out.println("=========================");
+
+	}
+
+}

src/class09/Code03_SmallerEqualBigger.java

@@ -0,0 +1,138 @@
+package class09;
+
+public class Code03_SmallerEqualBigger {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static Node listPartition1(Node head, int pivot) {
+		if (head == null) {
+			return head;
+		}
+		Node cur = head;
+		int i = 0;
+		while (cur != null) {
+			i++;
+			cur = cur.next;
+		}
+		Node[] nodeArr = new Node[i];
+		i = 0;
+		cur = head;
+		for (i = 0; i != nodeArr.length; i++) {
+			nodeArr[i] = cur;
+			cur = cur.next;
+		}
+		arrPartition(nodeArr, pivot);
+		for (i = 1; i != nodeArr.length; i++) {
+			nodeArr[i - 1].next = nodeArr[i];
+		}
+		nodeArr[i - 1].next = null;
+		return nodeArr[0];
+	}
+
+	public static void arrPartition(Node[] nodeArr, int pivot) {
+		int small = -1;
+		int big = nodeArr.length;
+		int index = 0;
+		while (index != big) {
+			if (nodeArr[index].value < pivot) {
+				swap(nodeArr, ++small, index++);
+			} else if (nodeArr[index].value == pivot) {
+				index++;
+			} else {
+				swap(nodeArr, --big, index);
+			}
+		}
+	}
+
+	public static void swap(Node[] nodeArr, int a, int b) {
+		Node tmp = nodeArr[a];
+		nodeArr[a] = nodeArr[b];
+		nodeArr[b] = tmp;
+	}
+
+	public static Node listPartition2(Node head, int pivot) {
+		Node sH = null; // small head
+		Node sT = null; // small tail
+		Node eH = null; // equal head
+		Node eT = null; // equal tail
+		Node mH = null; // big head
+		Node mT = null; // big tail
+		Node next = null; // save next node
+		// every node distributed to three lists
+		while (head != null) {
+			next = head.next;
+			head.next = null;
+			if (head.value < pivot) {
+				if (sH == null) {
+					sH = head;
+					sT = head;
+				} else {
+					sT.next = head;
+					sT = head;
+				}
+			} else if (head.value == pivot) {
+				if (eH == null) {
+					eH = head;
+					eT = head;
+				} else {
+					eT.next = head;
+					eT = head;
+				}
+			} else {
+				if (mH == null) {
+					mH = head;
+					mT = head;
+				} else {
+					mT.next = head;
+					mT = head;
+				}
+			}
+			head = next;
+		}
+		// 小于区域的尾巴，连等于区域的头，等于区域的尾巴连大于区域的头
+		if (sT != null) { // 如果有小于区域
+			sT.next = eH;
+			eT = eT == null ? sT : eT; // 下一步，谁去连大于区域的头，谁就变成eT
+		}
+		// 下一步，一定是需要用eT 去接 大于区域的头
+		// 有等于区域，eT -> 等于区域的尾结点
+		// 无等于区域，eT -> 小于区域的尾结点
+		// eT 尽量不为空的尾巴节点
+		if (eT != null) { // 如果小于区域和等于区域，不是都没有
+			eT.next = mH;
+		}
+		return sH != null ? sH : (eH != null ? eH : mH);
+	}
+
+	public static void printLinkedList(Node node) {
+		System.out.print("Linked List: ");
+		while (node != null) {
+			System.out.print(node.value + " ");
+			node = node.next;
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		Node head1 = new Node(7);
+		head1.next = new Node(9);
+		head1.next.next = new Node(1);
+		head1.next.next.next = new Node(8);
+		head1.next.next.next.next = new Node(5);
+		head1.next.next.next.next.next = new Node(2);
+		head1.next.next.next.next.next.next = new Node(5);
+		printLinkedList(head1);
+		// head1 = listPartition1(head1, 4);
+		head1 = listPartition2(head1, 5);
+		printLinkedList(head1);
+
+	}
+
+}

src/class09/Code04_CopyListWithRandom.java

@@ -0,0 +1,79 @@
+package class09;
+
+import java.util.HashMap;
+
+// 测试链接 : https://leetcode.com/problems/copy-list-with-random-pointer/
+public class Code04_CopyListWithRandom {
+
+	public static class Node {
+		int val;
+		Node next;
+		Node random;
+
+		public Node(int val) {
+			this.val = val;
+			this.next = null;
+			this.random = null;
+		}
+	}
+
+	public static Node copyRandomList1(Node head) {
+		// key 老节点
+		// value 新节点
+		HashMap<Node, Node> map = new HashMap<Node, Node>();
+		Node cur = head;
+		while (cur != null) {
+			map.put(cur, new Node(cur.val));
+			cur = cur.next;
+		}
+		cur = head;
+		while (cur != null) {
+			// cur 老
+			// map.get(cur) 新
+			// 新.next ->  cur.next克隆节点找到
+			map.get(cur).next = map.get(cur.next);
+			map.get(cur).random = map.get(cur.random);
+			cur = cur.next;
+		}
+		return map.get(head);
+	}
+
+	public static Node copyRandomList2(Node head) {
+		if (head == null) {
+			return null;
+		}
+		Node cur = head;
+		Node next = null;
+		// 1 -> 2 -> 3 -> null
+		// 1 -> 1' -> 2 -> 2' -> 3 -> 3'
+		while (cur != null) {
+			next = cur.next;
+			cur.next = new Node(cur.val);
+			cur.next.next = next;
+			cur = next;
+		}
+		cur = head;
+		Node copy = null;
+		// 1 1' 2 2' 3 3'
+		// 依次设置 1' 2' 3' random指针
+		while (cur != null) {
+			next = cur.next.next;
+			copy = cur.next;
+			copy.random = cur.random != null ? cur.random.next : null;
+			cur = next;
+		}
+		Node res = head.next;
+		cur = head;
+		// 老 新 混在一起，next方向上，random正确
+		// next方向上，把新老链表分离
+		while (cur != null) {
+			next = cur.next.next;
+			copy = cur.next;
+			cur.next = next;
+			copy.next = next != null ? next.next : null;
+			cur = next;
+		}
+		return res;
+	}
+
+}

src/class10/Code01_FindFirstIntersectNode.java

@@ -0,0 +1,170 @@
+package class10;
+
+public class Code01_FindFirstIntersectNode {
+
+	public static class Node {
+		public int value;
+		public Node next;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static Node getIntersectNode(Node head1, Node head2) {
+		if (head1 == null || head2 == null) {
+			return null;
+		}
+		Node loop1 = getLoopNode(head1);
+		Node loop2 = getLoopNode(head2);
+		if (loop1 == null && loop2 == null) {
+			return noLoop(head1, head2);
+		}
+		if (loop1 != null && loop2 != null) {
+			return bothLoop(head1, loop1, head2, loop2);
+		}
+		return null;
+	}
+
+	// 找到链表第一个入环节点，如果无环，返回null
+	public static Node getLoopNode(Node head) {
+		if (head == null || head.next == null || head.next.next == null) {
+			return null;
+		}
+		// n1 慢  n2 快
+		Node slow = head.next; // n1 -> slow
+		Node fast = head.next.next; // n2 -> fast
+		while (slow != fast) {
+			if (fast.next == null || fast.next.next == null) {
+				return null;
+			}
+			fast = fast.next.next;
+			slow = slow.next;
+		}
+		// slow fast  相遇
+		fast = head; // n2 -> walk again from head
+		while (slow != fast) {
+			slow = slow.next;
+			fast = fast.next;
+		}
+		return slow;
+	}
+
+	// 如果两个链表都无环，返回第一个相交节点，如果不想交，返回null
+	public static Node noLoop(Node head1, Node head2) {
+		if (head1 == null || head2 == null) {
+			return null;
+		}
+		Node cur1 = head1;
+		Node cur2 = head2;
+		int n = 0;
+		while (cur1.next != null) {
+			n++;
+			cur1 = cur1.next;
+		}
+		while (cur2.next != null) {
+			n--;
+			cur2 = cur2.next;
+		}
+		if (cur1 != cur2) {
+			return null;
+		}
+		// n  :  链表1长度减去链表2长度的值
+		cur1 = n > 0 ? head1 : head2; // 谁长，谁的头变成cur1
+		cur2 = cur1 == head1 ? head2 : head1; // 谁短，谁的头变成cur2
+		n = Math.abs(n);
+		while (n != 0) {
+			n--;
+			cur1 = cur1.next;
+		}
+		while (cur1 != cur2) {
+			cur1 = cur1.next;
+			cur2 = cur2.next;
+		}
+		return cur1;
+	}
+
+	// 两个有环链表，返回第一个相交节点，如果不想交返回null
+	public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
+		Node cur1 = null;
+		Node cur2 = null;
+		if (loop1 == loop2) {
+			cur1 = head1;
+			cur2 = head2;
+			int n = 0;
+			while (cur1 != loop1) {
+				n++;
+				cur1 = cur1.next;
+			}
+			while (cur2 != loop2) {
+				n--;
+				cur2 = cur2.next;
+			}
+			cur1 = n > 0 ? head1 : head2;
+			cur2 = cur1 == head1 ? head2 : head1;
+			n = Math.abs(n);
+			while (n != 0) {
+				n--;
+				cur1 = cur1.next;
+			}
+			while (cur1 != cur2) {
+				cur1 = cur1.next;
+				cur2 = cur2.next;
+			}
+			return cur1;
+		} else {
+			cur1 = loop1.next;
+			while (cur1 != loop1) {
+				if (cur1 == loop2) {
+					return loop1;
+				}
+				cur1 = cur1.next;
+			}
+			return null;
+		}
+	}
+
+	public static void main(String[] args) {
+		// 1->2->3->4->5->6->7->null
+		Node head1 = new Node(1);
+		head1.next = new Node(2);
+		head1.next.next = new Node(3);
+		head1.next.next.next = new Node(4);
+		head1.next.next.next.next = new Node(5);
+		head1.next.next.next.next.next = new Node(6);
+		head1.next.next.next.next.next.next = new Node(7);
+
+		// 0->9->8->6->7->null
+		Node head2 = new Node(0);
+		head2.next = new Node(9);
+		head2.next.next = new Node(8);
+		head2.next.next.next = head1.next.next.next.next.next; // 8->6
+		System.out.println(getIntersectNode(head1, head2).value);
+
+		// 1->2->3->4->5->6->7->4...
+		head1 = new Node(1);
+		head1.next = new Node(2);
+		head1.next.next = new Node(3);
+		head1.next.next.next = new Node(4);
+		head1.next.next.next.next = new Node(5);
+		head1.next.next.next.next.next = new Node(6);
+		head1.next.next.next.next.next.next = new Node(7);
+		head1.next.next.next.next.next.next = head1.next.next.next; // 7->4
+
+		// 0->9->8->2...
+		head2 = new Node(0);
+		head2.next = new Node(9);
+		head2.next.next = new Node(8);
+		head2.next.next.next = head1.next; // 8->2
+		System.out.println(getIntersectNode(head1, head2).value);
+
+		// 0->9->8->6->4->5->6..
+		head2 = new Node(0);
+		head2.next = new Node(9);
+		head2.next.next = new Node(8);
+		head2.next.next.next = head1.next.next.next.next.next; // 8->6
+		System.out.println(getIntersectNode(head1, head2).value);
+
+	}
+
+}

src/class10/Code02_RecursiveTraversalBT.java

@@ -0,0 +1,72 @@
+package class10;
+
+public class Code02_RecursiveTraversalBT {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int v) {
+			value = v;
+		}
+	}
+
+	public static void f(Node head) {
+		if (head == null) {
+			return;
+		}
+		// 1
+		f(head.left);
+		// 2
+		f(head.right);
+		// 3
+	}
+
+	// 先序打印所有节点
+	public static void pre(Node head) {
+		if (head == null) {
+			return;
+		}
+		System.out.println(head.value);
+		pre(head.left);
+		pre(head.right);
+	}
+
+	public static void in(Node head) {
+		if (head == null) {
+			return;
+		}
+		in(head.left);
+		System.out.println(head.value);
+		in(head.right);
+	}
+
+	public static void pos(Node head) {
+		if (head == null) {
+			return;
+		}
+		pos(head.left);
+		pos(head.right);
+		System.out.println(head.value);
+	}
+
+	public static void main(String[] args) {
+		Node head = new Node(1);
+		head.left = new Node(2);
+		head.right = new Node(3);
+		head.left.left = new Node(4);
+		head.left.right = new Node(5);
+		head.right.left = new Node(6);
+		head.right.right = new Node(7);
+
+		pre(head);
+		System.out.println("========");
+		in(head);
+		System.out.println("========");
+		pos(head);
+		System.out.println("========");
+
+	}
+
+}

src/class10/Code03_UnRecursiveTraversalBT.java

@@ -0,0 +1,118 @@
+package class10;
+
+import java.util.Stack;
+
+public class  Code03_UnRecursiveTraversalBT {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int v) {
+			value = v;
+		}
+	}
+
+	public static void pre(Node head) {
+		System.out.print("pre-order: ");
+		if (head != null) {
+			Stack<Node> stack = new Stack<Node>();
+			stack.add(head);
+			while (!stack.isEmpty()) {
+				head = stack.pop();
+				System.out.print(head.value + " ");
+				if (head.right != null) {
+					stack.push(head.right);
+				}
+				if (head.left != null) {
+					stack.push(head.left);
+				}
+			}
+		}
+		System.out.println();
+	}
+
+	public static void in(Node cur) {
+		System.out.print("in-order: ");
+		if (cur != null) {
+			Stack<Node> stack = new Stack<Node>();
+			while (!stack.isEmpty() || cur != null) {
+				if (cur != null) {
+					stack.push(cur);
+					cur = cur.left;
+				} else {
+					cur = stack.pop();
+					System.out.print(cur.value + " ");
+					cur = cur.right;
+				}
+			}
+		}
+		System.out.println();
+	}
+
+	public static void pos1(Node head) {
+		System.out.print("pos-order: ");
+		if (head != null) {
+			Stack<Node> s1 = new Stack<Node>();
+			Stack<Node> s2 = new Stack<Node>();
+			s1.push(head);
+			while (!s1.isEmpty()) {
+				head = s1.pop(); // 头 右 左
+				s2.push(head);
+				if (head.left != null) {
+					s1.push(head.left);
+				}
+				if (head.right != null) {
+					s1.push(head.right);
+				}
+			}
+			// 左 右 头
+			while (!s2.isEmpty()) {
+				System.out.print(s2.pop().value + " ");
+			}
+		}
+		System.out.println();
+	}
+
+	public static void pos2(Node h) {
+		System.out.print("pos-order: ");
+		if (h != null) {
+			Stack<Node> stack = new Stack<Node>();
+			stack.push(h);
+			Node c = null;
+			while (!stack.isEmpty()) {
+				c = stack.peek();
+				if (c.left != null && h != c.left && h != c.right) {
+					stack.push(c.left);
+				} else if (c.right != null && h != c.right) {
+					stack.push(c.right);
+				} else {
+					System.out.print(stack.pop().value + " ");
+					h = c;
+				}
+			}
+		}
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		Node head = new Node(1);
+		head.left = new Node(2);
+		head.right = new Node(3);
+		head.left.left = new Node(4);
+		head.left.right = new Node(5);
+		head.right.left = new Node(6);
+		head.right.right = new Node(7);
+
+		pre(head);
+		System.out.println("========");
+		in(head);
+		System.out.println("========");
+		pos1(head);
+		System.out.println("========");
+		pos2(head);
+		System.out.println("========");
+	}
+
+}

src/class11/Code01_LevelTraversalBT.java

@@ -0,0 +1,49 @@
+package class11;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Code01_LevelTraversalBT {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int v) {
+			value = v;
+		}
+	}
+
+	public static void level(Node head) {
+		if (head == null) {
+			return;
+		}
+		Queue<Node> queue = new LinkedList<>();
+		queue.add(head);
+		while (!queue.isEmpty()) {
+			Node cur = queue.poll();
+			System.out.println(cur.value);
+			if (cur.left != null) {
+				queue.add(cur.left);
+			}
+			if (cur.right != null) {
+				queue.add(cur.right);
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Node head = new Node(1);
+		head.left = new Node(2);
+		head.right = new Node(3);
+		head.left.left = new Node(4);
+		head.left.right = new Node(5);
+		head.right.left = new Node(6);
+		head.right.right = new Node(7);
+
+		level(head);
+		System.out.println("========");
+	}
+
+}

src/class11/Code02_SerializeAndReconstructTree.java

@@ -0,0 +1,264 @@
+package class11;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class Code02_SerializeAndReconstructTree {
+    /*
+     * 二叉树可以通过先序、后序或者按层遍历的方式序列化和反序列化，
+     * 以下代码全部实现了。
+     * 但是，二叉树无法通过中序遍历的方式实现序列化和反序列化
+     * 因为不同的两棵树，可能得到同样的中序序列，即便补了空位置也可能一样。
+     * 比如如下两棵树
+     *         __2
+     *        /
+     *       1
+     *       和
+     *       1__
+     *          \
+     *           2
+     * 补足空位置的中序遍历结果都是{ null, 1, null, 2, null}
+     *       
+     * */
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static Queue<String> preSerial(Node head) {
+		Queue<String> ans = new LinkedList<>();
+		pres(head, ans);
+		return ans;
+	}
+
+	public static void pres(Node head, Queue<String> ans) {
+		if (head == null) {
+			ans.add(null);
+		} else {
+			ans.add(String.valueOf(head.value));
+			pres(head.left, ans);
+			pres(head.right, ans);
+		}
+	}
+
+	public static Queue<String> inSerial(Node head) {
+		Queue<String> ans = new LinkedList<>();
+		ins(head, ans);
+		return ans;
+	}
+
+	public static void ins(Node head, Queue<String> ans) {
+		if (head == null) {
+			ans.add(null);
+		} else {
+			ins(head.left, ans);
+			ans.add(String.valueOf(head.value));
+			ins(head.right, ans);
+		}
+	}
+
+	public static Queue<String> posSerial(Node head) {
+		Queue<String> ans = new LinkedList<>();
+		poss(head, ans);
+		return ans;
+	}
+
+	public static void poss(Node head, Queue<String> ans) {
+		if (head == null) {
+			ans.add(null);
+		} else {
+			poss(head.left, ans);
+			poss(head.right, ans);
+			ans.add(String.valueOf(head.value));
+		}
+	}
+
+	public static Node buildByPreQueue(Queue<String> prelist) {
+		if (prelist == null || prelist.size() == 0) {
+			return null;
+		}
+		return preb(prelist);
+	}
+
+	public static Node preb(Queue<String> prelist) {
+		String value = prelist.poll();
+		if (value == null) {
+			return null;
+		}
+		Node head = new Node(Integer.valueOf(value));
+		head.left = preb(prelist);
+		head.right = preb(prelist);
+		return head;
+	}
+
+	public static Node buildByPosQueue(Queue<String> poslist) {
+		if (poslist == null || poslist.size() == 0) {
+			return null;
+		}
+		// 左右中  ->  stack(中右左)
+		Stack<String> stack = new Stack<>();
+		while (!poslist.isEmpty()) {
+			stack.push(poslist.poll());
+		}
+		return posb(stack);
+	}
+
+	public static Node posb(Stack<String> posstack) {
+		String value = posstack.pop();
+		if (value == null) {
+			return null;
+		}
+		Node head = new Node(Integer.valueOf(value));
+		head.right = posb(posstack);
+		head.left = posb(posstack);
+		return head;
+	}
+
+	public static Queue<String> levelSerial(Node head) {
+		Queue<String> ans = new LinkedList<>();
+		if (head == null) {
+			ans.add(null);
+		} else {
+			ans.add(String.valueOf(head.value));
+			Queue<Node> queue = new LinkedList<Node>();
+			queue.add(head);
+			while (!queue.isEmpty()) {
+				head = queue.poll(); // head 父   子
+				if (head.left != null) {
+					ans.add(String.valueOf(head.left.value));
+					queue.add(head.left);
+				} else {
+					ans.add(null);
+				}
+				if (head.right != null) {
+					ans.add(String.valueOf(head.right.value));
+					queue.add(head.right);
+				} else {
+					ans.add(null);
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static Node buildByLevelQueue(Queue<String> levelList) {
+		if (levelList == null || levelList.size() == 0) {
+			return null;
+		}
+		Node head = generateNode(levelList.poll());
+		Queue<Node> queue = new LinkedList<Node>();
+		if (head != null) {
+			queue.add(head);
+		}
+		Node node = null;
+		while (!queue.isEmpty()) {
+			node = queue.poll();
+			node.left = generateNode(levelList.poll());
+			node.right = generateNode(levelList.poll());
+			if (node.left != null) {
+				queue.add(node.left);
+			}
+			if (node.right != null) {
+				queue.add(node.right);
+			}
+		}
+		return head;
+	}
+
+	public static Node generateNode(String val) {
+		if (val == null) {
+			return null;
+		}
+		return new Node(Integer.valueOf(val));
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	// for test
+	public static boolean isSameValueStructure(Node head1, Node head2) {
+		if (head1 == null && head2 != null) {
+			return false;
+		}
+		if (head1 != null && head2 == null) {
+			return false;
+		}
+		if (head1 == null && head2 == null) {
+			return true;
+		}
+		if (head1.value != head2.value) {
+			return false;
+		}
+		return isSameValueStructure(head1.left, head2.left) && isSameValueStructure(head1.right, head2.right);
+	}
+
+	// for test
+	public static void printTree(Node head) {
+		System.out.println("Binary Tree:");
+		printInOrder(head, 0, "H", 17);
+		System.out.println();
+	}
+
+	public static void printInOrder(Node head, int height, String to, int len) {
+		if (head == null) {
+			return;
+		}
+		printInOrder(head.right, height + 1, "v", len);
+		String val = to + head.value + to;
+		int lenM = val.length();
+		int lenL = (len - lenM) / 2;
+		int lenR = len - lenM - lenL;
+		val = getSpace(lenL) + val + getSpace(lenR);
+		System.out.println(getSpace(height * len) + val);
+		printInOrder(head.left, height + 1, "^", len);
+	}
+
+	public static String getSpace(int num) {
+		String space = " ";
+		StringBuffer buf = new StringBuffer("");
+		for (int i = 0; i < num; i++) {
+			buf.append(space);
+		}
+		return buf.toString();
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 5;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		System.out.println("test begin");
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			Queue<String> pre = preSerial(head);
+			Queue<String> pos = posSerial(head);
+			Queue<String> level = levelSerial(head);
+			Node preBuild = buildByPreQueue(pre);
+			Node posBuild = buildByPosQueue(pos);
+			Node levelBuild = buildByLevelQueue(level);
+			if (!isSameValueStructure(preBuild, posBuild) || !isSameValueStructure(posBuild, levelBuild)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("test finish!");
+		
+	}
+}

src/class11/Code03_EncodeNaryTreeToBinaryTree.java

@@ -0,0 +1,86 @@
+package class11;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// 本题测试链接：https://leetcode.com/problems/encode-n-ary-tree-to-binary-tree
+public class Code03_EncodeNaryTreeToBinaryTree {
+
+	// 提交时不要提交这个类
+	public static class Node {
+		public int val;
+		public List<Node> children;
+
+		public Node() {
+		}
+
+		public Node(int _val) {
+			val = _val;
+		}
+
+		public Node(int _val, List<Node> _children) {
+			val = _val;
+			children = _children;
+		}
+	};
+
+	// 提交时不要提交这个类
+	public static class TreeNode {
+		int val;
+		TreeNode left;
+		TreeNode right;
+
+		TreeNode(int x) {
+			val = x;
+		}
+	}
+
+	// 只提交这个类即可
+	class Codec {
+		// Encodes an n-ary tree to a binary tree.
+		public TreeNode encode(Node root) {
+			if (root == null) {
+				return null;
+			}
+			TreeNode head = new TreeNode(root.val);
+			head.left = en(root.children);
+			return head;
+		}
+
+		private TreeNode en(List<Node> children) {
+			TreeNode head = null;
+			TreeNode cur = null;
+			for (Node child : children) {
+				TreeNode tNode = new TreeNode(child.val);
+				if (head == null) {
+					head = tNode;
+				} else {
+					cur.right = tNode;
+				}
+				cur = tNode;
+				cur.left = en(child.children);
+			}
+			return head;
+		}
+
+		// Decodes your binary tree to an n-ary tree.
+		public Node decode(TreeNode root) {
+			if (root == null) {
+				return null;
+			}
+			return new Node(root.val, de(root.left));
+		}
+
+		public List<Node> de(TreeNode root) {
+			List<Node> children = new ArrayList<>();
+			while (root != null) {
+				Node cur = new Node(root.val, de(root.left));
+				children.add(cur);
+				root = root.right;
+			}
+			return children;
+		}
+
+	}
+
+}

src/class11/Code04_PrintBinaryTree.java

@@ -0,0 +1,74 @@
+package class11;
+
+public class Code04_PrintBinaryTree {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static void printTree(Node head) {
+		System.out.println("Binary Tree:");
+		printInOrder(head, 0, "H", 17);
+		System.out.println();
+	}
+
+	public static void printInOrder(Node head, int height, String to, int len) {
+		if (head == null) {
+			return;
+		}
+		printInOrder(head.right, height + 1, "v", len);
+		String val = to + head.value + to;
+		int lenM = val.length();
+		int lenL = (len - lenM) / 2;
+		int lenR = len - lenM - lenL;
+		val = getSpace(lenL) + val + getSpace(lenR);
+		System.out.println(getSpace(height * len) + val);
+		printInOrder(head.left, height + 1, "^", len);
+	}
+
+	public static String getSpace(int num) {
+		String space = " ";
+		StringBuffer buf = new StringBuffer("");
+		for (int i = 0; i < num; i++) {
+			buf.append(space);
+		}
+		return buf.toString();
+	}
+
+	public static void main(String[] args) {
+		Node head = new Node(1);
+		head.left = new Node(-222222222);
+		head.right = new Node(3);
+		head.left.left = new Node(Integer.MIN_VALUE);
+		head.right.left = new Node(55555555);
+		head.right.right = new Node(66);
+		head.left.left.right = new Node(777);
+		printTree(head);
+
+		head = new Node(1);
+		head.left = new Node(2);
+		head.right = new Node(3);
+		head.left.left = new Node(4);
+		head.right.left = new Node(5);
+		head.right.right = new Node(6);
+		head.left.left.right = new Node(7);
+		printTree(head);
+
+		head = new Node(1);
+		head.left = new Node(1);
+		head.right = new Node(1);
+		head.left.left = new Node(1);
+		head.right.left = new Node(1);
+		head.right.right = new Node(1);
+		head.left.left.right = new Node(1);
+		printTree(head);
+
+	}
+
+}

src/class11/Code05_TreeMaxWidth.java

@@ -0,0 +1,114 @@
+package class11;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Code05_TreeMaxWidth {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static int maxWidthUseMap(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		Queue<Node> queue = new LinkedList<>();
+		queue.add(head);
+		// key 在 哪一层，value
+		HashMap<Node, Integer> levelMap = new HashMap<>();
+		levelMap.put(head, 1);
+		int curLevel = 1; // 当前你正在统计哪一层的宽度
+		int curLevelNodes = 0; // 当前层curLevel层，宽度目前是多少
+		int max = 0;
+		while (!queue.isEmpty()) {
+			Node cur = queue.poll();
+			int curNodeLevel = levelMap.get(cur);
+			if (cur.left != null) {
+				levelMap.put(cur.left, curNodeLevel + 1);
+				queue.add(cur.left);
+			}
+			if (cur.right != null) {
+				levelMap.put(cur.right, curNodeLevel + 1);
+				queue.add(cur.right);
+			}
+			if (curNodeLevel == curLevel) {
+				curLevelNodes++;
+			} else {
+				max = Math.max(max, curLevelNodes);
+				curLevel++;
+				curLevelNodes = 1;
+			}
+		}
+		max = Math.max(max, curLevelNodes);
+		return max;
+	}
+
+	public static int maxWidthNoMap(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		Queue<Node> queue = new LinkedList<>();
+		queue.add(head);
+		Node curEnd = head; // 当前层，最右节点是谁
+		Node nextEnd = null; // 下一层，最右节点是谁
+		int max = 0;
+		int curLevelNodes = 0; // 当前层的节点数
+		while (!queue.isEmpty()) {
+			Node cur = queue.poll();
+			if (cur.left != null) {
+				queue.add(cur.left);
+				nextEnd = cur.left;
+			}
+			if (cur.right != null) {
+				queue.add(cur.right);
+				nextEnd = cur.right;
+			}
+			curLevelNodes++;
+			if (cur == curEnd) {
+				max = Math.max(max, curLevelNodes);
+				curLevelNodes = 0;
+				curEnd = nextEnd;
+			}
+		}
+		return max;
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 10;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (maxWidthUseMap(head) != maxWidthNoMap(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+
+	}
+
+}

src/class11/Code06_SuccessorNode.java

@@ -0,0 +1,86 @@
+package class11;
+
+public class Code06_SuccessorNode {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+		public Node parent;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static Node getSuccessorNode(Node node) {
+		if (node == null) {
+			return node;
+		}
+		if (node.right != null) {
+			return getLeftMost(node.right);
+		} else { // 无右子树
+			Node parent = node.parent;
+			while (parent != null && parent.right == node) { // 当前节点是其父亲节点右孩子
+				node = parent;
+				parent = node.parent;
+			}
+			return parent;
+		}
+	}
+
+	public static Node getLeftMost(Node node) {
+		if (node == null) {
+			return node;
+		}
+		while (node.left != null) {
+			node = node.left;
+		}
+		return node;
+	}
+
+	public static void main(String[] args) {
+		Node head = new Node(6);
+		head.parent = null;
+		head.left = new Node(3);
+		head.left.parent = head;
+		head.left.left = new Node(1);
+		head.left.left.parent = head.left;
+		head.left.left.right = new Node(2);
+		head.left.left.right.parent = head.left.left;
+		head.left.right = new Node(4);
+		head.left.right.parent = head.left;
+		head.left.right.right = new Node(5);
+		head.left.right.right.parent = head.left.right;
+		head.right = new Node(9);
+		head.right.parent = head;
+		head.right.left = new Node(8);
+		head.right.left.parent = head.right;
+		head.right.left.left = new Node(7);
+		head.right.left.left.parent = head.right.left;
+		head.right.right = new Node(10);
+		head.right.right.parent = head.right;
+
+		Node test = head.left.left;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.left.left.right;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.left;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.left.right;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.left.right.right;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.right.left.left;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.right.left;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.right;
+		System.out.println(test.value + " next: " + getSuccessorNode(test).value);
+		test = head.right.right; // 10's next is null
+		System.out.println(test.value + " next: " + getSuccessorNode(test));
+	}
+
+}

src/class11/Code07_PaperFolding.java

@@ -0,0 +1,28 @@
+package class11;
+
+public class Code07_PaperFolding {
+
+	public static void printAllFolds(int N) {
+		process(1, N, true);
+		System.out.println();
+	}
+
+	// 当前你来了一个节点，脑海中想象的！
+	// 这个节点在第i层，一共有N层，N固定不变的
+	// 这个节点如果是凹的话，down = T
+	// 这个节点如果是凸的话，down = F
+	// 函数的功能：中序打印以你想象的节点为头的整棵树！
+	public static void process(int i, int N, boolean down) {
+		if (i > N) {
+			return;
+		}
+		process(i + 1, N, true);
+		System.out.print(down ? "凹 " : "凸 ");
+		process(i + 1, N, false);
+	}
+
+	public static void main(String[] args) {
+		int N = 4;
+		printAllFolds(N);
+	}
+}

src/class12/Code01_IsCBT.java

@@ -0,0 +1,147 @@
+package class12;
+
+import java.util.LinkedList;
+
+public class Code01_IsCBT {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static boolean isCBT1(Node head) {
+		if (head == null) {
+			return true;
+		}
+		LinkedList<Node> queue = new LinkedList<>();
+		// 是否遇到过左右两个孩子不双全的节点
+		boolean leaf = false;
+		Node l = null;
+		Node r = null;
+		queue.add(head);
+		while (!queue.isEmpty()) {
+			head = queue.poll();
+			l = head.left;
+			r = head.right;
+			if (
+			// 如果遇到了不双全的节点之后，又发现当前节点不是叶节点
+			    (leaf && (l != null || r != null)) 
+			    || 
+			    (l == null && r != null)
+
+			) {
+				return false;
+			}
+			if (l != null) {
+				queue.add(l);
+			}
+			if (r != null) {
+				queue.add(r);
+			}
+			if (l == null || r == null) {
+				leaf = true;
+			}
+		}
+		return true;
+	}
+
+	public static boolean isCBT2(Node head) {
+		if (head == null) {
+			return true;
+		}
+		return process(head).isCBT;
+	}
+
+	// 对每一棵子树，是否是满二叉树、是否是完全二叉树、高度
+	public static class Info {
+		public boolean isFull;
+		public boolean isCBT;
+		public int height;
+
+		public Info(boolean full, boolean cbt, int h) {
+			isFull = full;
+			isCBT = cbt;
+			height = h;
+		}
+	}
+
+	public static Info process(Node X) {
+		if (X == null) {
+			return new Info(true, true, 0);
+		}
+		Info leftInfo = process(X.left);
+		Info rightInfo = process(X.right);
+		
+
+		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+		
+		boolean isFull = leftInfo.isFull 
+				&& 
+				rightInfo.isFull 
+				&& leftInfo.height == rightInfo.height;
+		
+		
+		boolean isCBT = false;
+		if (isFull) {
+			isCBT = true;
+		} else { // 以x为头整棵树，不满
+			if (leftInfo.isCBT && rightInfo.isCBT) {
+				
+				
+				if (leftInfo.isCBT 
+						&& rightInfo.isFull 
+						&& leftInfo.height == rightInfo.height + 1) {
+					isCBT = true;
+				}
+				if (leftInfo.isFull 
+						&& 
+						rightInfo.isFull 
+						&& leftInfo.height == rightInfo.height + 1) {
+					isCBT = true;
+				}
+				if (leftInfo.isFull 
+						&& rightInfo.isCBT && leftInfo.height == rightInfo.height) {
+					isCBT = true;
+				}
+				
+				
+			}
+		}
+		return new Info(isFull, isCBT, height);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 5;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (isCBT1(head) != isCBT2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class12/Code02_IsBST.java

@@ -0,0 +1,125 @@
+package class12;
+
+import java.util.ArrayList;
+
+public class Code02_IsBST {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static boolean isBST1(Node head) {
+		if (head == null) {
+			return true;
+		}
+		ArrayList<Node> arr = new ArrayList<>();
+		in(head, arr);
+		for (int i = 1; i < arr.size(); i++) {
+			if (arr.get(i).value <= arr.get(i - 1).value) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void in(Node head, ArrayList<Node> arr) {
+		if (head == null) {
+			return;
+		}
+		in(head.left, arr);
+		arr.add(head);
+		in(head.right, arr);
+	}
+
+	public static boolean isBST2(Node head) {
+		if (head == null) {
+			return true;
+		}
+		return process(head).isBST;
+	}
+
+	public static class Info {
+		public boolean isBST;
+		public int max;
+		public int min;
+
+		public Info(boolean i, int ma, int mi) {
+			isBST = i;
+			max = ma;
+			min = mi;
+		}
+
+	}
+
+	public static Info process(Node x) {
+		if (x == null) {
+			return null;
+		}
+		Info leftInfo = process(x.left);
+		Info rightInfo = process(x.right);
+		int max = x.value;
+//		if (leftInfo != null) {
+//			max = Math.max(max, leftInfo.max);
+//		}
+		if (rightInfo != null) {
+			max = Math.max(max, rightInfo.max);
+		}
+		int min = x.value;
+		if (leftInfo != null) {
+			min = Math.min(min, leftInfo.min);
+		}
+//		if (rightInfo != null) {
+//			min = Math.min(min, rightInfo.min);
+//		}
+		boolean isBST = true;
+		if (leftInfo != null && !leftInfo.isBST) {
+			isBST = false;
+		}
+		if (rightInfo != null && !rightInfo.isBST) {
+			isBST = false;
+		}
+		if (leftInfo != null && leftInfo.max >= x.value) {
+			isBST = false;
+		}
+		if (rightInfo != null && rightInfo.min <= x.value) {
+			isBST = false;
+		}
+		return new Info(isBST, max, min);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxValue = 100;
+		int testTimes = 1000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (isBST1(head) != isBST2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class12/Code03_IsBalanced.java

@@ -0,0 +1,102 @@
+package class12;
+
+public class Code03_IsBalanced {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static boolean isBalanced1(Node head) {
+		boolean[] ans = new boolean[1];
+		ans[0] = true;
+		process1(head, ans);
+		return ans[0];
+	}
+
+	public static int process1(Node head, boolean[] ans) {
+		if (!ans[0] || head == null) {
+			return -1;
+		}
+		int leftHeight = process1(head.left, ans);
+		int rightHeight = process1(head.right, ans);
+		if (Math.abs(leftHeight - rightHeight) > 1) {
+			ans[0] = false;
+		}
+		return Math.max(leftHeight, rightHeight) + 1;
+	}
+
+	public static boolean isBalanced2(Node head) {
+		return process(head).isBalanced;
+	}
+	
+	public static class Info{
+		public boolean isBalanced;
+		public int height;
+		
+		public Info(boolean i, int h) {
+			isBalanced = i;
+			height = h;
+		}
+	}
+	
+	public static Info process(Node x) {
+		if(x == null) {
+			return new Info(true, 0);
+		}
+		Info leftInfo = process(x.left);
+		Info rightInfo = process(x.right);
+		int height = Math.max(leftInfo.height, rightInfo.height)  + 1;
+		boolean isBalanced = true;
+		if(!leftInfo.isBalanced) {
+			isBalanced = false;
+		}
+		if(!rightInfo.isBalanced) {
+			isBalanced = false;
+		}
+		if(Math.abs(leftInfo.height - rightInfo.height) > 1) {
+			isBalanced = false;
+		}
+		return new Info(isBalanced, height);
+	}
+	
+	
+	
+	
+	
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 5;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (isBalanced1(head) != isBalanced2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class12/Code04_IsFull.java

@@ -0,0 +1,109 @@
+package class12;
+
+public class Code04_IsFull {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	// 第一种方法
+	// 收集整棵树的高度h，和节点数n
+	// 只有满二叉树满足 : 2 ^ h - 1 == n
+	public static boolean isFull1(Node head) {
+		if (head == null) {
+			return true;
+		}
+		Info1 all = process1(head);
+		return (1 << all.height) - 1 == all.nodes;
+	}
+
+	public static class Info1 {
+		public int height;
+		public int nodes;
+
+		public Info1(int h, int n) {
+			height = h;
+			nodes = n;
+		}
+	}
+
+	public static Info1 process1(Node head) {
+		if (head == null) {
+			return new Info1(0, 0);
+		}
+		Info1 leftInfo = process1(head.left);
+		Info1 rightInfo = process1(head.right);
+		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+		int nodes = leftInfo.nodes + rightInfo.nodes + 1;
+		return new Info1(height, nodes);
+	}
+
+	// 第二种方法
+	// 收集子树是否是满二叉树
+	// 收集子树的高度
+	// 左树满 && 右树满 && 左右树高度一样 -> 整棵树是满的
+	public static boolean isFull2(Node head) {
+		if (head == null) {
+			return true;
+		}
+		return process2(head).isFull;
+	}
+
+	public static class Info2 {
+		public boolean isFull;
+		public int height;
+
+		public Info2(boolean f, int h) {
+			isFull = f;
+			height = h;
+		}
+	}
+
+	public static Info2 process2(Node h) {
+		if (h == null) {
+			return new Info2(true, 0);
+		}
+		Info2 leftInfo = process2(h.left);
+		Info2 rightInfo = process2(h.right);
+		boolean isFull = leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height;
+		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+		return new Info2(isFull, height);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 5;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		System.out.println("测试开始");
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (isFull1(head) != isFull2(head)) {
+				System.out.println("出错了!");
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}

src/class12/Code05_MaxSubBSTSize.java

@@ -0,0 +1,240 @@
+package class12;
+
+import java.util.ArrayList;
+
+public class Code05_MaxSubBSTSize {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static int getBSTSize(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		ArrayList<Node> arr = new ArrayList<>();
+		in(head, arr);
+		for (int i = 1; i < arr.size(); i++) {
+			if (arr.get(i).value <= arr.get(i - 1).value) {
+				return 0;
+			}
+		}
+		return arr.size();
+	}
+
+	public static void in(Node head, ArrayList<Node> arr) {
+		if (head == null) {
+			return;
+		}
+		in(head.left, arr);
+		arr.add(head);
+		in(head.right, arr);
+	}
+
+	public static int maxSubBSTSize1(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		int h = getBSTSize(head);
+		if (h != 0) {
+			return h;
+		}
+		return Math.max(maxSubBSTSize1(head.left), maxSubBSTSize1(head.right));
+	}
+
+//	public static int maxSubBSTSize2(Node head) {
+//		if (head == null) {
+//			return 0;
+//		}
+//		return process(head).maxSubBSTSize;
+//	}
+//	
+//	
+//	
+//	
+//	
+//	
+//	
+//	
+//	
+//	// 任何子树
+//	public static class Info {
+//		public boolean isAllBST;
+//		public int maxSubBSTSize;
+//		public int min;
+//		public int max;
+//
+//		public Info(boolean is, int size, int mi, int ma) {
+//			isAllBST = is;
+//			maxSubBSTSize = size;
+//			min = mi;
+//			max = ma;
+//		}
+//	}
+//	
+//	
+//	
+//	
+//	public static Info process(Node X) {
+//		if(X == null) {
+//			return null;
+//		}
+//		Info leftInfo = process(X.left);
+//		Info rightInfo = process(X.right);
+//		
+//		
+//		
+//		int min = X.value;
+//		int max = X.value;
+//		
+//		if(leftInfo != null) {
+//			min = Math.min(min, leftInfo.min);
+//			max = Math.max(max, leftInfo.max);
+//		}
+//		if(rightInfo != null) {
+//			min = Math.min(min, rightInfo.min);
+//			max = Math.max(max, rightInfo.max);
+//		}
+//		
+//		
+//		
+//		
+//		
+//		
+//
+//		int maxSubBSTSize = 0;
+//		if(leftInfo != null) {
+//			maxSubBSTSize = leftInfo.maxSubBSTSize;
+//		}
+//		if(rightInfo !=null) {
+//			maxSubBSTSize = Math.max(maxSubBSTSize, rightInfo.maxSubBSTSize);
+//		}
+//		boolean isAllBST = false;
+//		
+//		
+//		if(
+//				// 左树整体需要是搜索二叉树
+//				(  leftInfo == null ? true : leftInfo.isAllBST    )
+//				&&
+//				(  rightInfo == null ? true : rightInfo.isAllBST    )
+//				&&
+//				// 左树最大值<x
+//				(leftInfo == null ? true : leftInfo.max < X.value)
+//				&&
+//				(rightInfo == null ? true : rightInfo.min > X.value)
+//				
+//				
+//				) {
+//			
+//			maxSubBSTSize = 
+//					(leftInfo == null ? 0 : leftInfo.maxSubBSTSize)
+//					+
+//					(rightInfo == null ? 0 : rightInfo.maxSubBSTSize)
+//					+
+//					1;
+//					isAllBST = true;
+//			
+//			
+//		}
+//		return new Info(isAllBST, maxSubBSTSize, min, max);
+//	}
+
+	public static int maxSubBSTSize2(Node head) {
+		if(head == null) {
+			return 0;
+		}
+		return process(head).maxBSTSubtreeSize;
+	}
+
+	public static class Info {
+		public int maxBSTSubtreeSize;
+		public int allSize;
+		public int max;
+		public int min;
+
+		public Info(int m, int a, int ma, int mi) {
+			maxBSTSubtreeSize = m;
+			allSize = a;
+			max = ma;
+			min = mi;
+		}
+	}
+
+	public static Info process(Node x) {
+		if (x == null) {
+			return null;
+		}
+		Info leftInfo = process(x.left);
+		Info rightInfo = process(x.right);
+		int max = x.value;
+		int min = x.value;
+		int allSize = 1;
+		if (leftInfo != null) {
+			max = Math.max(leftInfo.max, max);
+			min = Math.min(leftInfo.min, min);
+			allSize += leftInfo.allSize;
+		}
+		if (rightInfo != null) {
+			max = Math.max(rightInfo.max, max);
+			min = Math.min(rightInfo.min, min);
+			allSize += rightInfo.allSize;
+		}
+		int p1 = -1;
+		if (leftInfo != null) {
+			p1 = leftInfo.maxBSTSubtreeSize;
+		}
+		int p2 = -1;
+		if (rightInfo != null) {
+			p2 = rightInfo.maxBSTSubtreeSize;
+		}
+		int p3 = -1;
+		boolean leftBST = leftInfo == null ? true : (leftInfo.maxBSTSubtreeSize == leftInfo.allSize);
+		boolean rightBST = rightInfo == null ? true : (rightInfo.maxBSTSubtreeSize == rightInfo.allSize);
+		if (leftBST && rightBST) {
+			boolean leftMaxLessX = leftInfo == null ? true : (leftInfo.max < x.value);
+			boolean rightMinMoreX = rightInfo == null ? true : (x.value < rightInfo.min);
+			if (leftMaxLessX && rightMinMoreX) {
+				int leftSize = leftInfo == null ? 0 : leftInfo.allSize;
+				int rightSize = rightInfo == null ? 0 : rightInfo.allSize;
+				p3 = leftSize + rightSize + 1;
+			}
+		}
+		return new Info(Math.max(p1, Math.max(p2, p3)), allSize, max, min);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (maxSubBSTSize1(head) != maxSubBSTSize2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class12/Code06_MaxDistance.java

@@ -0,0 +1,180 @@
+package class12;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class Code06_MaxDistance {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static int maxDistance1(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		ArrayList<Node> arr = getPrelist(head);
+		HashMap<Node, Node> parentMap = getParentMap(head);
+		int max = 0;
+		for (int i = 0; i < arr.size(); i++) {
+			for (int j = i; j < arr.size(); j++) {
+				max = Math.max(max, distance(parentMap, arr.get(i), arr.get(j)));
+			}
+		}
+		return max;
+	}
+
+	public static ArrayList<Node> getPrelist(Node head) {
+		ArrayList<Node> arr = new ArrayList<>();
+		fillPrelist(head, arr);
+		return arr;
+	}
+
+	public static void fillPrelist(Node head, ArrayList<Node> arr) {
+		if (head == null) {
+			return;
+		}
+		arr.add(head);
+		fillPrelist(head.left, arr);
+		fillPrelist(head.right, arr);
+	}
+
+	public static HashMap<Node, Node> getParentMap(Node head) {
+		HashMap<Node, Node> map = new HashMap<>();
+		map.put(head, null);
+		fillParentMap(head, map);
+		return map;
+	}
+
+	public static void fillParentMap(Node head, HashMap<Node, Node> parentMap) {
+		if (head.left != null) {
+			parentMap.put(head.left, head);
+			fillParentMap(head.left, parentMap);
+		}
+		if (head.right != null) {
+			parentMap.put(head.right, head);
+			fillParentMap(head.right, parentMap);
+		}
+	}
+
+	public static int distance(HashMap<Node, Node> parentMap, Node o1, Node o2) {
+		HashSet<Node> o1Set = new HashSet<>();
+		Node cur = o1;
+		o1Set.add(cur);
+		while (parentMap.get(cur) != null) {
+			cur = parentMap.get(cur);
+			o1Set.add(cur);
+		}
+		cur = o2;
+		while (!o1Set.contains(cur)) {
+			cur = parentMap.get(cur);
+		}
+		Node lowestAncestor = cur;
+		cur = o1;
+		int distance1 = 1;
+		while (cur != lowestAncestor) {
+			cur = parentMap.get(cur);
+			distance1++;
+		}
+		cur = o2;
+		int distance2 = 1;
+		while (cur != lowestAncestor) {
+			cur = parentMap.get(cur);
+			distance2++;
+		}
+		return distance1 + distance2 - 1;
+	}
+
+//	public static int maxDistance2(Node head) {
+//		return process(head).maxDistance;
+//	}
+//
+//	public static class Info {
+//		public int maxDistance;
+//		public int height;
+//
+//		public Info(int dis, int h) {
+//			maxDistance = dis;
+//			height = h;
+//		}
+//	}
+//
+//	public static Info process(Node X) {
+//		if (X == null) {
+//			return new Info(0, 0);
+//		}
+//		Info leftInfo = process(X.left);
+//		Info rightInfo = process(X.right);
+//		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+//		int maxDistance = Math.max(
+//				Math.max(leftInfo.maxDistance, rightInfo.maxDistance),
+//				leftInfo.height + rightInfo.height + 1);
+//		return new Info(maxDistance, height);
+//	}
+
+	public static int maxDistance2(Node head) {
+		return process(head).maxDistance;
+	}
+
+	public static class Info {
+		public int maxDistance;
+		public int height;
+
+		public Info(int m, int h) {
+			maxDistance = m;
+			height = h;
+		}
+
+	}
+
+	public static Info process(Node x) {
+		if (x == null) {
+			return new Info(0, 0);
+		}
+		Info leftInfo = process(x.left);
+		Info rightInfo = process(x.right);
+		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+		int p1 = leftInfo.maxDistance;
+		int p2 = rightInfo.maxDistance;
+		int p3 = leftInfo.height + rightInfo.height + 1;
+		int maxDistance = Math.max(Math.max(p1, p2), p3);
+		return new Info(maxDistance, height);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (maxDistance1(head) != maxDistance2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class13/Code01_IsCBT.java

@@ -0,0 +1,117 @@
+package class13;
+
+import java.util.LinkedList;
+
+public class Code01_IsCBT {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static boolean isCBT1(Node head) {
+		if (head == null) {
+			return true;
+		}
+		LinkedList<Node> queue = new LinkedList<>();
+		// 是否遇到过左右两个孩子不双全的节点
+		boolean leaf = false;
+		Node l = null;
+		Node r = null;
+		queue.add(head);
+		while (!queue.isEmpty()) {
+			head = queue.poll();
+			l = head.left;
+			r = head.right;
+			if (
+			// 如果遇到了不双全的节点之后，又发现当前节点不是叶节点
+			(leaf && (l != null || r != null)) || (l == null && r != null)
+
+			) {
+				return false;
+			}
+			if (l != null) {
+				queue.add(l);
+			}
+			if (r != null) {
+				queue.add(r);
+			}
+			if (l == null || r == null) {
+				leaf = true;
+			}
+		}
+		return true;
+	}
+
+	public static boolean isCBT2(Node head) {
+		return process(head).isCBT;
+	}
+
+	public static class Info {
+		public boolean isFull;
+		public boolean isCBT;
+		public int height;
+
+		public Info(boolean full, boolean cbt, int h) {
+			isFull = full;
+			isCBT = cbt;
+			height = h;
+		}
+	}
+
+	public static Info process(Node x) {
+		if (x == null) {
+			return new Info(true, true, 0);
+		}
+		Info leftInfo = process(x.left);
+		Info rightInfo = process(x.right);
+		int height = Math.max(leftInfo.height, rightInfo.height) + 1;
+		boolean isFull = leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height;
+		boolean isCBT = false;
+		if (leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height) {
+			isCBT = true;
+		} else if (leftInfo.isCBT && rightInfo.isFull && leftInfo.height == rightInfo.height + 1) {
+			isCBT = true;
+		} else if (leftInfo.isFull && rightInfo.isFull && leftInfo.height == rightInfo.height + 1) {
+			isCBT = true;
+		} else if (leftInfo.isFull && rightInfo.isCBT && leftInfo.height == rightInfo.height) {
+			isCBT = true;
+		}
+		return new Info(isFull, isCBT, height);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 5;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (isCBT1(head) != isCBT2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class13/Code02_MaxSubBSTHead.java

@@ -0,0 +1,136 @@
+package class13;
+
+import java.util.ArrayList;
+
+public class Code02_MaxSubBSTHead {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static int getBSTSize(Node head) {
+		if (head == null) {
+			return 0;
+		}
+		ArrayList<Node> arr = new ArrayList<>();
+		in(head, arr);
+		for (int i = 1; i < arr.size(); i++) {
+			if (arr.get(i).value <= arr.get(i - 1).value) {
+				return 0;
+			}
+		}
+		return arr.size();
+	}
+
+	public static void in(Node head, ArrayList<Node> arr) {
+		if (head == null) {
+			return;
+		}
+		in(head.left, arr);
+		arr.add(head);
+		in(head.right, arr);
+	}
+
+	public static Node maxSubBSTHead1(Node head) {
+		if (head == null) {
+			return null;
+		}
+		if (getBSTSize(head) != 0) {
+			return head;
+		}
+		Node leftAns = maxSubBSTHead1(head.left);
+		Node rightAns = maxSubBSTHead1(head.right);
+		return getBSTSize(leftAns) >= getBSTSize(rightAns) ? leftAns : rightAns;
+	}
+
+	public static Node maxSubBSTHead2(Node head) {
+		if (head == null) {
+			return null;
+		}
+		return process(head).maxSubBSTHead;
+	}
+
+	// 每一棵子树
+	public static class Info {
+		public Node maxSubBSTHead;
+		public int maxSubBSTSize;
+		public int min;
+		public int max;
+
+		public Info(Node h, int size, int mi, int ma) {
+			maxSubBSTHead = h;
+			maxSubBSTSize = size;
+			min = mi;
+			max = ma;
+		}
+	}
+
+	public static Info process(Node X) {
+		if (X == null) {
+			return null;
+		}
+		Info leftInfo = process(X.left);
+		Info rightInfo = process(X.right);
+		int min = X.value;
+		int max = X.value;
+		Node maxSubBSTHead = null;
+		int maxSubBSTSize = 0;
+		if (leftInfo != null) {
+			min = Math.min(min, leftInfo.min);
+			max = Math.max(max, leftInfo.max);
+			maxSubBSTHead = leftInfo.maxSubBSTHead;
+			maxSubBSTSize = leftInfo.maxSubBSTSize;
+		}
+		if (rightInfo != null) {
+			min = Math.min(min, rightInfo.min);
+			max = Math.max(max, rightInfo.max);
+			if (rightInfo.maxSubBSTSize > maxSubBSTSize) {
+				maxSubBSTHead = rightInfo.maxSubBSTHead;
+				maxSubBSTSize = rightInfo.maxSubBSTSize;
+			}
+		}
+		if ((leftInfo == null ? true : (leftInfo.maxSubBSTHead == X.left && leftInfo.max < X.value))
+				&& (rightInfo == null ? true : (rightInfo.maxSubBSTHead == X.right && rightInfo.min > X.value))) {
+			maxSubBSTHead = X;
+			maxSubBSTSize = (leftInfo == null ? 0 : leftInfo.maxSubBSTSize)
+					+ (rightInfo == null ? 0 : rightInfo.maxSubBSTSize) + 1;
+		}
+		return new Info(maxSubBSTHead, maxSubBSTSize, min, max);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			if (maxSubBSTHead1(head) != maxSubBSTHead2(head)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class13/Code03_lowestAncestor.java

@@ -0,0 +1,141 @@
+package class13;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class Code03_lowestAncestor {
+
+	public static class Node {
+		public int value;
+		public Node left;
+		public Node right;
+
+		public Node(int data) {
+			this.value = data;
+		}
+	}
+
+	public static Node lowestAncestor1(Node head, Node o1, Node o2) {
+		if (head == null) {
+			return null;
+		}
+		// key的父节点是value
+		HashMap<Node, Node> parentMap = new HashMap<>();
+		parentMap.put(head, null);
+		fillParentMap(head, parentMap);
+		HashSet<Node> o1Set = new HashSet<>();
+		Node cur = o1;
+		o1Set.add(cur);
+		while (parentMap.get(cur) != null) {
+			cur = parentMap.get(cur);
+			o1Set.add(cur);
+		}
+		cur = o2;
+		while (!o1Set.contains(cur)) {
+			cur = parentMap.get(cur);
+		}
+		return cur;
+	}
+
+	public static void fillParentMap(Node head, HashMap<Node, Node> parentMap) {
+		if (head.left != null) {
+			parentMap.put(head.left, head);
+			fillParentMap(head.left, parentMap);
+		}
+		if (head.right != null) {
+			parentMap.put(head.right, head);
+			fillParentMap(head.right, parentMap);
+		}
+	}
+
+	public static Node lowestAncestor2(Node head, Node a, Node b) {
+		return process(head, a, b).ans;
+	}
+
+	public static class Info {
+		public boolean findA;
+		public boolean findB;
+		public Node ans;
+
+		public Info(boolean fA, boolean fB, Node an) {
+			findA = fA;
+			findB = fB;
+			ans = an;
+		}
+	}
+
+	public static Info process(Node x, Node a, Node b) {
+		if (x == null) {
+			return new Info(false, false, null);
+		}
+		Info leftInfo = process(x.left, a, b);
+		Info rightInfo = process(x.right, a, b);
+		boolean findA = (x == a) || leftInfo.findA || rightInfo.findA;
+		boolean findB = (x == b) || leftInfo.findB || rightInfo.findB;
+		Node ans = null;
+		if (leftInfo.ans != null) {
+			ans = leftInfo.ans;
+		} else if (rightInfo.ans != null) {
+			ans = rightInfo.ans;
+		} else {
+			if (findA && findB) {
+				ans = x;
+			}
+		}
+		return new Info(findA, findB, ans);
+	}
+
+	// for test
+	public static Node generateRandomBST(int maxLevel, int maxValue) {
+		return generate(1, maxLevel, maxValue);
+	}
+
+	// for test
+	public static Node generate(int level, int maxLevel, int maxValue) {
+		if (level > maxLevel || Math.random() < 0.5) {
+			return null;
+		}
+		Node head = new Node((int) (Math.random() * maxValue));
+		head.left = generate(level + 1, maxLevel, maxValue);
+		head.right = generate(level + 1, maxLevel, maxValue);
+		return head;
+	}
+
+	// for test
+	public static Node pickRandomOne(Node head) {
+		if (head == null) {
+			return null;
+		}
+		ArrayList<Node> arr = new ArrayList<>();
+		fillPrelist(head, arr);
+		int randomIndex = (int) (Math.random() * arr.size());
+		return arr.get(randomIndex);
+	}
+
+	// for test
+	public static void fillPrelist(Node head, ArrayList<Node> arr) {
+		if (head == null) {
+			return;
+		}
+		arr.add(head);
+		fillPrelist(head.left, arr);
+		fillPrelist(head.right, arr);
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxValue = 100;
+		int testTimes = 1000000;
+		for (int i = 0; i < testTimes; i++) {
+			Node head = generateRandomBST(maxLevel, maxValue);
+			Node o1 = pickRandomOne(head);
+			Node o2 = pickRandomOne(head);
+			if (lowestAncestor1(head, o1, o2) != lowestAncestor2(head, o1, o2)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class13/Code04_MaxHappy.java

@@ -0,0 +1,116 @@
+package class13;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Code04_MaxHappy {
+
+	public static class Employee {
+		public int happy;
+		public List<Employee> nexts;
+
+		public Employee(int h) {
+			happy = h;
+			nexts = new ArrayList<>();
+		}
+
+	}
+
+	public static int maxHappy1(Employee boss) {
+		if (boss == null) {
+			return 0;
+		}
+		return process1(boss, false);
+	}
+
+	// 当前来到的节点叫cur，
+	// up表示cur的上级是否来，
+	// 该函数含义：
+	// 如果up为true，表示在cur上级已经确定来，的情况下，cur整棵树能够提供最大的快乐值是多少？
+	// 如果up为false，表示在cur上级已经确定不来，的情况下，cur整棵树能够提供最大的快乐值是多少？
+	public static int process1(Employee cur, boolean up) {
+		if (up) { // 如果cur的上级来的话，cur没得选，只能不来
+			int ans = 0;
+			for (Employee next : cur.nexts) {
+				ans += process1(next, false);
+			}
+			return ans;
+		} else { // 如果cur的上级不来的话，cur可以选，可以来也可以不来
+			int p1 = cur.happy;
+			int p2 = 0;
+			for (Employee next : cur.nexts) {
+				p1 += process1(next, true);
+				p2 += process1(next, false);
+			}
+			return Math.max(p1, p2);
+		}
+	}
+
+	public static int maxHappy2(Employee head) {
+		Info allInfo = process(head);
+		return Math.max(allInfo.no, allInfo.yes);
+	}
+
+	public static class Info {
+		public int no;
+		public int yes;
+
+		public Info(int n, int y) {
+			no = n;
+			yes = y;
+		}
+	}
+
+	public static Info process(Employee x) {
+		if (x == null) {
+			return new Info(0, 0);
+		}
+		int no = 0;
+		int yes = x.happy;
+		for (Employee next : x.nexts) {
+			Info nextInfo = process(next);
+			no += Math.max(nextInfo.no, nextInfo.yes);
+			yes += nextInfo.no;
+
+		}
+		return new Info(no, yes);
+	}
+
+	// for test
+	public static Employee genarateBoss(int maxLevel, int maxNexts, int maxHappy) {
+		if (Math.random() < 0.02) {
+			return null;
+		}
+		Employee boss = new Employee((int) (Math.random() * (maxHappy + 1)));
+		genarateNexts(boss, 1, maxLevel, maxNexts, maxHappy);
+		return boss;
+	}
+
+	// for test
+	public static void genarateNexts(Employee e, int level, int maxLevel, int maxNexts, int maxHappy) {
+		if (level > maxLevel) {
+			return;
+		}
+		int nextsSize = (int) (Math.random() * (maxNexts + 1));
+		for (int i = 0; i < nextsSize; i++) {
+			Employee next = new Employee((int) (Math.random() * (maxHappy + 1)));
+			e.nexts.add(next);
+			genarateNexts(next, level + 1, maxLevel, maxNexts, maxHappy);
+		}
+	}
+
+	public static void main(String[] args) {
+		int maxLevel = 4;
+		int maxNexts = 7;
+		int maxHappy = 100;
+		int testTimes = 100000;
+		for (int i = 0; i < testTimes; i++) {
+			Employee boss = genarateBoss(maxLevel, maxNexts, maxHappy);
+			if (maxHappy1(boss) != maxHappy2(boss)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class13/Code05_LowestLexicography.java

@@ -0,0 +1,116 @@
+package class13;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.TreeSet;
+
+public class Code05_LowestLexicography {
+
+	public static String lowestString1(String[] strs) {
+		if (strs == null || strs.length == 0) {
+			return "";
+		}
+		TreeSet<String> ans = process(strs);
+		return ans.size() == 0 ? "" : ans.first();
+	}
+
+	// strs中所有字符串全排列，返回所有可能的结果
+	public static TreeSet<String> process(String[] strs) {
+		TreeSet<String> ans = new TreeSet<>();
+		if (strs.length == 0) {
+			ans.add("");
+			return ans;
+		}
+		for (int i = 0; i < strs.length; i++) {
+			String first = strs[i];
+			String[] nexts = removeIndexString(strs, i);
+			TreeSet<String> next = process(nexts);
+			for (String cur : next) {
+				ans.add(first + cur);
+			}
+		}
+		return ans;
+	}
+
+	// {"abc", "cks", "bct"}
+	// 0 1 2
+	// removeIndexString(arr , 1) -> {"abc", "bct"}
+	public static String[] removeIndexString(String[] arr, int index) {
+		int N = arr.length;
+		String[] ans = new String[N - 1];
+		int ansIndex = 0;
+		for (int i = 0; i < N; i++) {
+			if (i != index) {
+				ans[ansIndex++] = arr[i];
+			}
+		}
+		return ans;
+	}
+
+	public static class MyComparator implements Comparator<String> {
+		@Override
+		public int compare(String a, String b) {
+			return (a + b).compareTo(b + a);
+		}
+	}
+
+	public static String lowestString2(String[] strs) {
+		if (strs == null || strs.length == 0) {
+			return "";
+		}
+		Arrays.sort(strs, new MyComparator());
+		String res = "";
+		for (int i = 0; i < strs.length; i++) {
+			res += strs[i];
+		}
+		return res;
+	}
+
+	// for test
+	public static String generateRandomString(int strLen) {
+		char[] ans = new char[(int) (Math.random() * strLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			int value = (int) (Math.random() * 5);
+			ans[i] = (Math.random() <= 0.5) ? (char) (65 + value) : (char) (97 + value);
+		}
+		return String.valueOf(ans);
+	}
+
+	// for test
+	public static String[] generateRandomStringArray(int arrLen, int strLen) {
+		String[] ans = new String[(int) (Math.random() * arrLen) + 1];
+		for (int i = 0; i < ans.length; i++) {
+			ans[i] = generateRandomString(strLen);
+		}
+		return ans;
+	}
+
+	// for test
+	public static String[] copyStringArray(String[] arr) {
+		String[] ans = new String[arr.length];
+		for (int i = 0; i < ans.length; i++) {
+			ans[i] = String.valueOf(arr[i]);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		int arrLen = 6;
+		int strLen = 5;
+		int testTimes = 10000;
+		System.out.println("test begin");
+		for (int i = 0; i < testTimes; i++) {
+			String[] arr1 = generateRandomStringArray(arrLen, strLen);
+			String[] arr2 = copyStringArray(arr1);
+			if (!lowestString1(arr1).equals(lowestString2(arr2))) {
+				for (String str : arr1) {
+					System.out.print(str + ",");
+				}
+				System.out.println();
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class14/Code01_Light.java

@@ -0,0 +1,85 @@
+package class14;
+
+import java.util.HashSet;
+
+public class Code01_Light {
+
+	public static int minLight1(String road) {
+		if (road == null || road.length() == 0) {
+			return 0;
+		}
+		return process(road.toCharArray(), 0, new HashSet<>());
+	}
+
+	// str[index....]位置，自由选择放灯还是不放灯
+	// str[0..index-1]位置呢？已经做完决定了，那些放了灯的位置，存在lights里
+	// 要求选出能照亮所有.的方案，并且在这些有效的方案中，返回最少需要几个灯
+	public static int process(char[] str, int index, HashSet<Integer> lights) {
+		if (index == str.length) { // 结束的时候
+			for (int i = 0; i < str.length; i++) {
+				if (str[i] != 'X') { // 当前位置是点的话
+					if (!lights.contains(i - 1) && !lights.contains(i) && !lights.contains(i + 1)) {
+						return Integer.MAX_VALUE;
+					}
+				}
+			}
+			return lights.size();
+		} else { // str还没结束
+			// i X .
+			int no = process(str, index + 1, lights);
+			int yes = Integer.MAX_VALUE;
+			if (str[index] == '.') {
+				lights.add(index);
+				yes = process(str, index + 1, lights);
+				lights.remove(index);
+			}
+			return Math.min(no, yes);
+		}
+	}
+
+	public static int minLight2(String road) {
+		char[] str = road.toCharArray();
+		int i = 0;
+		int light = 0;
+		while (i < str.length) {
+			if (str[i] == 'X') {
+				i++;
+			} else {
+				light++;
+				if (i + 1 == str.length) {
+					break;
+				} else { // 有i位置  i+ 1   X  .
+					if (str[i + 1] == 'X') {
+						i = i + 2;
+					} else {
+						i = i + 3;
+					}
+				}
+			}
+		}
+		return light;
+	}
+
+	// for test
+	public static String randomString(int len) {
+		char[] res = new char[(int) (Math.random() * len) + 1];
+		for (int i = 0; i < res.length; i++) {
+			res[i] = Math.random() < 0.5 ? 'X' : '.';
+		}
+		return String.valueOf(res);
+	}
+
+	public static void main(String[] args) {
+		int len = 20;
+		int testTime = 1000;
+		for (int i = 0; i < testTime; i++) {
+			String test = randomString(len);
+			int ans1 = minLight1(test);
+			int ans2 = minLight2(test);
+			if (ans1 != ans2) {
+				System.out.println("oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+}

src/class14/Code02_LessMoneySplitGold.java

@@ -0,0 +1,79 @@
+package class14;
+
+import java.util.PriorityQueue;
+
+public class Code02_LessMoneySplitGold {
+
+	// 纯暴力！
+	public static int lessMoney1(int[] arr) {
+		if (arr == null || arr.length == 0) {
+			return 0;
+		}
+		return process(arr, 0);
+	}
+
+	// 等待合并的数都在arr里，pre之前的合并行为产生了多少总代价
+	// arr中只剩一个数字的时候，停止合并，返回最小的总代价
+	public static int process(int[] arr, int pre) {
+		if (arr.length == 1) {
+			return pre;
+		}
+		int ans = Integer.MAX_VALUE;
+		for (int i = 0; i < arr.length; i++) {
+			for (int j = i + 1; j < arr.length; j++) {
+				ans = Math.min(ans, process(copyAndMergeTwo(arr, i, j), pre + arr[i] + arr[j]));
+			}
+		}
+		return ans;
+	}
+
+	public static int[] copyAndMergeTwo(int[] arr, int i, int j) {
+		int[] ans = new int[arr.length - 1];
+		int ansi = 0;
+		for (int arri = 0; arri < arr.length; arri++) {
+			if (arri != i && arri != j) {
+				ans[ansi++] = arr[arri];
+			}
+		}
+		ans[ansi] = arr[i] + arr[j];
+		return ans;
+	}
+
+	public static int lessMoney2(int[] arr) {
+		PriorityQueue<Integer> pQ = new PriorityQueue<>();
+		for (int i = 0; i < arr.length; i++) {
+			pQ.add(arr[i]);
+		}
+		int sum = 0;
+		int cur = 0;
+		while (pQ.size() > 1) {
+			cur = pQ.poll() + pQ.poll();
+			sum += cur;
+			pQ.add(cur);
+		}
+		return sum;
+	}
+
+	// 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) (Math.random() * (maxValue + 1));
+		}
+		return arr;
+	}
+
+	public static void main(String[] args) {
+		int testTime = 100000;
+		int maxSize = 6;
+		int maxValue = 1000;
+		for (int i = 0; i < testTime; i++) {
+			int[] arr = generateRandomArray(maxSize, maxValue);
+			if (lessMoney1(arr) != lessMoney2(arr)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class14/Code03_BestArrange.java

@@ -0,0 +1,111 @@
+package class14;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code03_BestArrange {
+
+	public static class Program {
+		public int start;
+		public int end;
+
+		public Program(int start, int end) {
+			this.start = start;
+			this.end = end;
+		}
+	}
+
+	// 暴力！所有情况都尝试！
+	public static int bestArrange1(Program[] programs) {
+		if (programs == null || programs.length == 0) {
+			return 0;
+		}
+		return process(programs, 0, 0);
+	}
+
+	// 还剩下的会议都放在programs里
+	// done之前已经安排了多少会议的数量
+	// timeLine目前来到的时间点是什么
+
+	// 目前来到timeLine的时间点，已经安排了done多的会议，剩下的会议programs可以自由安排
+	// 返回能安排的最多会议数量
+	public static int process(Program[] programs, int done, int timeLine) {
+		if (programs.length == 0) {
+			return done;
+		}
+		// 还剩下会议
+		int max = done;
+		// 当前安排的会议是什么会，每一个都枚举
+		for (int i = 0; i < programs.length; i++) {
+			if (programs[i].start >= timeLine) {
+				Program[] next = copyButExcept(programs, i);
+				max = Math.max(max, process(next, done + 1, programs[i].end));
+			}
+		}
+		return max;
+	}
+
+	public static Program[] copyButExcept(Program[] programs, int i) {
+		Program[] ans = new Program[programs.length - 1];
+		int index = 0;
+		for (int k = 0; k < programs.length; k++) {
+			if (k != i) {
+				ans[index++] = programs[k];
+			}
+		}
+		return ans;
+	}
+
+	// 会议的开始时间和结束时间，都是数值，不会 < 0
+	public static int bestArrange2(Program[] programs) {
+		Arrays.sort(programs, new ProgramComparator());
+		int timeLine = 0;
+		int result = 0;
+		// 依次遍历每一个会议，结束时间早的会议先遍历
+		for (int i = 0; i < programs.length; i++) {
+			if (timeLine <= programs[i].start) {
+				result++;
+				timeLine = programs[i].end;
+			}
+		}
+		return result;
+	}
+
+	public static class ProgramComparator implements Comparator<Program> {
+
+		@Override
+		public int compare(Program o1, Program o2) {
+			return o1.end - o2.end;
+		}
+
+	}
+
+	// for test
+	public static Program[] generatePrograms(int programSize, int timeMax) {
+		Program[] ans = new Program[(int) (Math.random() * (programSize + 1))];
+		for (int i = 0; i < ans.length; i++) {
+			int r1 = (int) (Math.random() * (timeMax + 1));
+			int r2 = (int) (Math.random() * (timeMax + 1));
+			if (r1 == r2) {
+				ans[i] = new Program(r1, r1 + 1);
+			} else {
+				ans[i] = new Program(Math.min(r1, r2), Math.max(r1, r2));
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		int programSize = 12;
+		int timeMax = 20;
+		int timeTimes = 1000000;
+		for (int i = 0; i < timeTimes; i++) {
+			Program[] programs = generatePrograms(programSize, timeMax);
+			if (bestArrange1(programs) != bestArrange2(programs)) {
+				System.out.println("Oops!");
+			}
+		}
+		System.out.println("finish!");
+	}
+
+}

src/class14/Code04_IPO.java

@@ -0,0 +1,59 @@
+package class14;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Code04_IPO {
+
+	// 最多K个项目
+	// W是初始资金
+	// Profits[] Capital[] 一定等长
+	// 返回最终最大的资金
+	public static int findMaximizedCapital(int K, int W, int[] Profits, int[] Capital) {
+
+		PriorityQueue<Program> minCostQ = new PriorityQueue<>(new MinCostComparator());
+		PriorityQueue<Program> maxProfitQ = new PriorityQueue<>(new MaxProfitComparator());
+		for (int i = 0; i < Profits.length; i++) {
+			minCostQ.add(new Program(Profits[i], Capital[i]));
+		}
+		for (int i = 0; i < K; i++) {
+			while (!minCostQ.isEmpty() && minCostQ.peek().c <= W) {
+				maxProfitQ.add(minCostQ.poll());
+			}
+			if (maxProfitQ.isEmpty()) {
+				return W;
+			}
+			W += maxProfitQ.poll().p;
+		}
+		return W;
+	}
+
+	public static class Program {
+		public int p;
+		public int c;
+
+		public Program(int p, int c) {
+			this.p = p;
+			this.c = c;
+		}
+	}
+
+	public static class MinCostComparator implements Comparator<Program> {
+		//花费从小到大
+		@Override
+		public int compare(Program o1, Program o2) {
+			return o1.c - o2.c;
+		}
+
+	}
+
+	public static class MaxProfitComparator implements Comparator<Program> {
+		//利润从大到小
+		@Override
+		public int compare(Program o1, Program o2) {
+			return o2.p - o1.p;
+		}
+
+	}
+
+}

src/class14/Code05_UnionFind.java

@@ -0,0 +1,76 @@
+package class14;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Stack;
+
+public class Code05_UnionFind {
+
+	public static class Node<V> {
+		V value;
+
+		public Node(V v) {
+			value = v;
+		}
+	}
+
+	/**
+	 * nodes表用来记录每一个结点
+	 * parents表用来记录每一个结点所在集合的代表结点
+	 * size表只有当一个结点是代表结点的时候才会有记录
+	 * @param <V>
+	 */
+	public static class UnionFind<V> {
+		public HashMap<V, Node<V>> nodes;
+		public HashMap<Node<V>, Node<V>> parents;
+		public HashMap<Node<V>, Integer> sizeMap;
+
+		public UnionFind(List<V> values) {
+			nodes = new HashMap<>();
+			parents = new HashMap<>();
+			sizeMap = new HashMap<>();
+			for (V cur : values) {
+				Node<V> node = new Node<>(cur);
+				nodes.put(cur, node);
+				parents.put(node, node);
+				sizeMap.put(node, 1);
+			}
+		}
+
+		// 给你一个节点，请你往上到不能再往上，把代表返回
+		public Node<V> findFather(Node<V> cur) {
+			Stack<Node<V>> path = new Stack<>();
+			while (cur != parents.get(cur)) {
+				path.push(cur);
+				cur = parents.get(cur);
+			}
+			while (!path.isEmpty()) {
+				parents.put(path.pop(), cur);
+			}
+			return cur;
+		}
+
+		public boolean isSameSet(V a, V b) {
+			return findFather(nodes.get(a)) == findFather(nodes.get(b));
+		}
+
+		public void union(V a, V b) {
+			Node<V> aHead = findFather(nodes.get(a));
+			Node<V> bHead = findFather(nodes.get(b));
+			if (aHead != bHead) {
+				int aSetSize = sizeMap.get(aHead);
+				int bSetSize = sizeMap.get(bHead);
+				Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
+				Node<V> small = big == aHead ? bHead : aHead;
+				parents.put(small, big);
+				sizeMap.put(big, aSetSize + bSetSize);
+				sizeMap.remove(small);
+			}
+		}
+
+		public int sets() {
+			return sizeMap.size();
+		}
+
+	}
+}

src/class15/Code01_FriendCircles.java

@@ -0,0 +1,78 @@
+package class15;
+
+// 本题为leetcode原题
+// 测试链接：https://leetcode.com/problems/friend-circles/
+// 可以直接通过
+public class Code01_FriendCircles {
+
+	public static int findCircleNum(int[][] M) {
+		int N = M.length;
+		// {0} {1} {2} {N-1}
+		UnionFind unionFind = new UnionFind(N);
+		for (int i = 0; i < N; i++) {
+			for (int j = i + 1; j < N; j++) {
+				if (M[i][j] == 1) { // i和j互相认识
+					unionFind.union(i, j);
+				}
+			}
+		}
+		return unionFind.sets();
+	}
+
+	public static class UnionFind {
+		// parent[i] = k ： i的父亲是k
+		private int[] parent;
+		// size[i] = k ： 如果i是代表节点，size[i]才有意义，否则无意义
+		// i所在的集合大小是多少
+		private int[] size;
+		// 辅助结构
+		private int[] help;
+		// 一共有多少个集合
+		private int sets;
+
+		public UnionFind(int N) {
+			parent = new int[N];
+			size = new int[N];
+			help = new int[N];
+			sets = N;
+			for (int i = 0; i < N; i++) {
+				parent[i] = i;
+				size[i] = 1;
+			}
+		}
+
+		// 从i开始一直往上，往上到不能再往上，代表节点，返回
+		// 这个过程要做路径压缩
+		private int find(int i) {
+			int hi = 0;
+			while (i != parent[i]) {
+				help[hi++] = i;
+				i = parent[i];
+			}
+			for (hi--; hi >= 0; hi--) {
+				parent[help[hi]] = i;
+			}
+			return i;
+		}
+
+		public void union(int i, int j) {
+			int f1 = find(i);
+			int f2 = find(j);
+			if (f1 != f2) {
+				if (size[f1] >= size[f2]) {
+					size[f1] += size[f2];
+					parent[f2] = f1;
+				} else {
+					size[f2] += size[f1];
+					parent[f1] = f2;
+				}
+				sets--;
+			}
+		}
+
+		public int sets() {
+			return sets;
+		}
+	}
+
+}

src/class15/Code02_NumberOfIslands.java

@@ -0,0 +1,317 @@
+package class15;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Stack;
+
+// 本题为leetcode原题
+// 测试链接：https://leetcode.com/problems/number-of-islands/
+// 所有方法都可以直接通过
+public class Code02_NumberOfIslands {
+
+	public static int numIslands3(char[][] board) {
+		int islands = 0;
+		for (int i = 0; i < board.length; i++) {
+			for (int j = 0; j < board[0].length; j++) {
+				if (board[i][j] == '1') {
+					islands++;
+					infect(board, i, j);
+				}
+			}
+		}
+		return islands;
+	}
+
+	// 从(i,j)这个位置出发，把所有练成一片的'1'字符，变成0
+	public static void infect(char[][] board, int i, int j) {
+		if (i < 0 || i == board.length || j < 0 || j == board[0].length || board[i][j] != '1') {
+			return;
+		}
+		board[i][j] = 0;
+		infect(board, i - 1, j);
+		infect(board, i + 1, j);
+		infect(board, i, j - 1);
+		infect(board, i, j + 1);
+	}
+
+	public static int numIslands1(char[][] board) {
+		int row = board.length;
+		int col = board[0].length;
+		Dot[][] dots = new Dot[row][col];
+		List<Dot> dotList = new ArrayList<>();
+		for (int i = 0; i < row; i++) {
+			for (int j = 0; j < col; j++) {
+				if (board[i][j] == '1') {
+					dots[i][j] = new Dot();
+					dotList.add(dots[i][j]);
+				}
+			}
+		}
+		UnionFind1<Dot> uf = new UnionFind1<>(dotList);
+		for (int j = 1; j < col; j++) {
+			// (0,j)  (0,0)跳过了  (0,1) (0,2) (0,3)
+			if (board[0][j - 1] == '1' && board[0][j] == '1') {
+				uf.union(dots[0][j - 1], dots[0][j]);
+			}
+		}
+		for (int i = 1; i < row; i++) {
+			if (board[i - 1][0] == '1' && board[i][0] == '1') {
+				uf.union(dots[i - 1][0], dots[i][0]);
+			}
+		}
+		for (int i = 1; i < row; i++) {
+			for (int j = 1; j < col; j++) {
+				if (board[i][j] == '1') {
+					if (board[i][j - 1] == '1') {
+						uf.union(dots[i][j - 1], dots[i][j]);
+					}
+					if (board[i - 1][j] == '1') {
+						uf.union(dots[i - 1][j], dots[i][j]);
+					}
+				}
+			}
+		}
+		return uf.sets();
+	}
+
+	public static class Dot {
+
+	}
+
+	public static class Node<V> {
+
+		V value;
+
+		public Node(V v) {
+			value = v;
+		}
+
+	}
+
+	public static class UnionFind1<V> {
+		public HashMap<V, Node<V>> nodes;
+		public HashMap<Node<V>, Node<V>> parents;
+		public HashMap<Node<V>, Integer> sizeMap;
+
+		public UnionFind1(List<V> values) {
+			nodes = new HashMap<>();
+			parents = new HashMap<>();
+			sizeMap = new HashMap<>();
+			for (V cur : values) {
+				Node<V> node = new Node<>(cur);
+				nodes.put(cur, node);
+				parents.put(node, node);
+				sizeMap.put(node, 1);
+			}
+		}
+
+		public Node<V> findFather(Node<V> cur) {
+			Stack<Node<V>> path = new Stack<>();
+			while (cur != parents.get(cur)) {
+				path.push(cur);
+				cur = parents.get(cur);
+			}
+			while (!path.isEmpty()) {
+				parents.put(path.pop(), cur);
+			}
+			return cur;
+		}
+
+		public void union(V a, V b) {
+			Node<V> aHead = findFather(nodes.get(a));
+			Node<V> bHead = findFather(nodes.get(b));
+			if (aHead != bHead) {
+				int aSetSize = sizeMap.get(aHead);
+				int bSetSize = sizeMap.get(bHead);
+				Node<V> big = aSetSize >= bSetSize ? aHead : bHead;
+				Node<V> small = big == aHead ? bHead : aHead;
+				parents.put(small, big);
+				sizeMap.put(big, aSetSize + bSetSize);
+				sizeMap.remove(small);
+			}
+		}
+
+		public int sets() {
+			return sizeMap.size();
+		}
+
+	}
+
+	public static int numIslands2(char[][] board) {
+		int row = board.length;
+		int col = board[0].length;
+		UnionFind2 uf = new UnionFind2(board);
+		for (int j = 1; j < col; j++) {
+			if (board[0][j - 1] == '1' && board[0][j] == '1') {
+				uf.union(0, j - 1, 0, j);
+			}
+		}
+		for (int i = 1; i < row; i++) {
+			if (board[i - 1][0] == '1' && board[i][0] == '1') {
+				uf.union(i - 1, 0, i, 0);
+			}
+		}
+		for (int i = 1; i < row; i++) {
+			for (int j = 1; j < col; j++) {
+				if (board[i][j] == '1') {
+					if (board[i][j - 1] == '1') {
+						uf.union(i, j - 1, i, j);
+					}
+					if (board[i - 1][j] == '1') {
+						uf.union(i - 1, j, i, j);
+					}
+				}
+			}
+		}
+		return uf.sets();
+	}
+
+	public static class UnionFind2 {
+		private int[] parent;
+		private int[] size;
+		private int[] help;
+		private int col;
+		private int sets;
+
+		public UnionFind2(char[][] board) {
+			col = board[0].length;
+			sets = 0;
+			int row = board.length;
+			int len = row * col;
+			parent = new int[len];
+			size = new int[len];
+			help = new int[len];
+			for (int r = 0; r < row; r++) {
+				for (int c = 0; c < col; c++) {
+					if (board[r][c] == '1') {
+						int i = index(r, c);
+						parent[i] = i;
+						size[i] = 1;
+						sets++;
+					}
+				}
+			}
+		}
+
+		// (r,c) -> i
+		private int index(int r, int c) {
+			return r * col + c;
+		}
+
+		// 原始位置 -> 下标
+		private int find(int i) {
+			int hi = 0;
+			while (i != parent[i]) {
+				help[hi++] = i;
+				i = parent[i];
+			}
+			for (hi--; hi >= 0; hi--) {
+				parent[help[hi]] = i;
+			}
+			return i;
+		}
+
+		public void union(int r1, int c1, int r2, int c2) {
+			int i1 = index(r1, c1);
+			int i2 = index(r2, c2);
+			int f1 = find(i1);
+			int f2 = find(i2);
+			if (f1 != f2) {
+				if (size[f1] >= size[f2]) {
+					size[f1] += size[f2];
+					parent[f2] = f1;
+				} else {
+					size[f2] += size[f1];
+					parent[f1] = f2;
+				}
+				sets--;
+			}
+		}
+
+		public int sets() {
+			return sets;
+		}
+
+	}
+
+	// 为了测试
+	public static char[][] generateRandomMatrix(int row, int col) {
+		char[][] board = new char[row][col];
+		for (int i = 0; i < row; i++) {
+			for (int j = 0; j < col; j++) {
+				board[i][j] = Math.random() < 0.5 ? '1' : '0';
+			}
+		}
+		return board;
+	}
+
+	// 为了测试
+	public static char[][] copy(char[][] board) {
+		int row = board.length;
+		int col = board[0].length;
+		char[][] ans = new char[row][col];
+		for (int i = 0; i < row; i++) {
+			for (int j = 0; j < col; j++) {
+				ans[i][j] = board[i][j];
+			}
+		}
+		return ans;
+	}
+
+	// 为了测试
+	public static void main(String[] args) {
+		int row = 0;
+		int col = 0;
+		char[][] board1 = null;
+		char[][] board2 = null;
+		char[][] board3 = null;
+		long start = 0;
+		long end = 0;
+
+		row = 1000;
+		col = 1000;
+		board1 = generateRandomMatrix(row, col);
+		board2 = copy(board1);
+		board3 = copy(board1);
+
+		System.out.println("感染方法、并查集(map实现)、并查集(数组实现)的运行结果和运行时间");
+		System.out.println("随机生成的二维矩阵规模 : " + row + " * " + col);
+
+		start = System.currentTimeMillis();
+		System.out.println("感染方法的运行结果: " + numIslands3(board1));
+		end = System.currentTimeMillis();
+		System.out.println("感染方法的运行时间: " + (end - start) + " ms");
+
+		start = System.currentTimeMillis();
+		System.out.println("并查集(map实现)的运行结果: " + numIslands1(board2));
+		end = System.currentTimeMillis();
+		System.out.println("并查集(map实现)的运行时间: " + (end - start) + " ms");
+
+		start = System.currentTimeMillis();
+		System.out.println("并查集(数组实现)的运行结果: " + numIslands2(board3));
+		end = System.currentTimeMillis();
+		System.out.println("并查集(数组实现)的运行时间: " + (end - start) + " ms");
+
+		System.out.println();
+
+		row = 10000;
+		col = 10000;
+		board1 = generateRandomMatrix(row, col);
+		board3 = copy(board1);
+		System.out.println("感染方法、并查集(数组实现)的运行结果和运行时间");
+		System.out.println("随机生成的二维矩阵规模 : " + row + " * " + col);
+
+		start = System.currentTimeMillis();
+		System.out.println("感染方法的运行结果: " + numIslands3(board1));
+		end = System.currentTimeMillis();
+		System.out.println("感染方法的运行时间: " + (end - start) + " ms");
+
+		start = System.currentTimeMillis();
+		System.out.println("并查集(数组实现)的运行结果: " + numIslands2(board3));
+		end = System.currentTimeMillis();
+		System.out.println("并查集(数组实现)的运行时间: " + (end - start) + " ms");
+
+	}
+
+}

src/class15/Code03_NumberOfIslandsII.java

@@ -0,0 +1,165 @@
+package class15;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+// 本题为leetcode原题
+// 测试链接：https://leetcode.com/problems/number-of-islands-ii/
+// 所有方法都可以直接通过
+public class Code03_NumberOfIslandsII {
+
+	public static List<Integer> numIslands21(int m, int n, int[][] positions) {
+		UnionFind1 uf = new UnionFind1(m, n);
+		List<Integer> ans = new ArrayList<>();
+		for (int[] position : positions) {
+			ans.add(uf.connect(position[0], position[1]));
+		}
+		return ans;
+	}
+
+	public static class UnionFind1 {
+		private int[] parent;
+		private int[] size;
+		private int[] help;
+		private final int row;
+		private final int col;
+		private int sets;
+
+		public UnionFind1(int m, int n) {
+			row = m;
+			col = n;
+			sets = 0;
+			int len = row * col;
+			parent = new int[len];
+			size = new int[len];
+			help = new int[len];
+		}
+
+		private int index(int r, int c) {
+			return r * col + c;
+		}
+
+		private int find(int i) {
+			int hi = 0;
+			while (i != parent[i]) {
+				help[hi++] = i;
+				i = parent[i];
+			}
+			for (hi--; hi >= 0; hi--) {
+				parent[help[hi]] = i;
+			}
+			return i;
+		}
+
+		private void union(int r1, int c1, int r2, int c2) {
+			if (r1 < 0 || r1 == row || r2 < 0 || r2 == row || c1 < 0 || c1 == col || c2 < 0 || c2 == col) {
+				return;
+			}
+			int i1 = index(r1, c1);
+			int i2 = index(r2, c2);
+			if (size[i1] == 0 || size[i2] == 0) {
+				return;
+			}
+			int f1 = find(i1);
+			int f2 = find(i2);
+			if (f1 != f2) {
+				if (size[f1] >= size[f2]) {
+					size[f1] += size[f2];
+					parent[f2] = f1;
+				} else {
+					size[f2] += size[f1];
+					parent[f1] = f2;
+				}
+				sets--;
+			}
+		}
+
+		public int connect(int r, int c) {
+			int index = index(r, c);
+			if (size[index] == 0) {
+				parent[index] = index;
+				size[index] = 1;
+				sets++;
+				union(r - 1, c, r, c);
+				union(r + 1, c, r, c);
+				union(r, c - 1, r, c);
+				union(r, c + 1, r, c);
+			}
+			return sets;
+		}
+
+	}
+
+	// 课上讲的如果m*n比较大，会经历很重的初始化，而k比较小，怎么优化的方法
+	public static List<Integer> numIslands22(int m, int n, int[][] positions) {
+		UnionFind2 uf = new UnionFind2();
+		List<Integer> ans = new ArrayList<>();
+		for (int[] position : positions) {
+			ans.add(uf.connect(position[0], position[1]));
+		}
+		return ans;
+	}
+
+	public static class UnionFind2 {
+		private HashMap<String, String> parent;
+		private HashMap<String, Integer> size;
+		private ArrayList<String> help;
+		private int sets;
+
+		public UnionFind2() {
+			parent = new HashMap<>();
+			size = new HashMap<>();
+			help = new ArrayList<>();
+			sets = 0;
+		}
+
+		private String find(String cur) {
+			while (!cur.equals(parent.get(cur))) {
+				help.add(cur);
+				cur = parent.get(cur);
+			}
+			for (String str : help) {
+				parent.put(str, cur);
+			}
+			help.clear();
+			return cur;
+		}
+
+		private void union(String s1, String s2) {
+			if (parent.containsKey(s1) && parent.containsKey(s2)) {
+				String f1 = find(s1);
+				String f2 = find(s2);
+				if (!f1.equals(f2)) {
+					int size1 = size.get(f1);
+					int size2 = size.get(f2);
+					String big = size1 >= size2 ? f1 : f2;
+					String small = big == f1 ? f2 : f1;
+					parent.put(small, big);
+					size.put(big, size1 + size2);
+					sets--;
+				}
+			}
+		}
+
+		public int connect(int r, int c) {
+			String key = String.valueOf(r) + "_" + String.valueOf(c);
+			if (!parent.containsKey(key)) {
+				parent.put(key, key);
+				size.put(key, 1);
+				sets++;
+				String up = String.valueOf(r - 1) + "_" + String.valueOf(c);
+				String down = String.valueOf(r + 1) + "_" + String.valueOf(c);
+				String left = String.valueOf(r) + "_" + String.valueOf(c - 1);
+				String right = String.valueOf(r) + "_" + String.valueOf(c + 1);
+				union(up, key);
+				union(down, key);
+				union(left, key);
+				union(right, key);
+			}
+			return sets;
+		}
+
+	}
+
+}

src/class16/Code01_BFS.java

@@ -0,0 +1,30 @@
+package class16;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Code01_BFS {
+
+	// 从node出发，进行宽度优先遍历
+	public static void bfs(Node start) {
+		if (start == null) {
+			return;
+		}
+		Queue<Node> queue = new LinkedList<>();
+		HashSet<Node> set = new HashSet<>();
+		queue.add(start);
+		set.add(start);
+		while (!queue.isEmpty()) {
+			Node cur = queue.poll();
+			System.out.println(cur.value);
+			for (Node next : cur.nexts) {
+				if (!set.contains(next)) {
+					set.add(next);
+					queue.add(next);
+				}
+			}
+		}
+	}
+
+}

src/class16/Code02_DFS.java

@@ -0,0 +1,34 @@
+package class16;
+
+import java.util.HashSet;
+import java.util.Stack;
+
+public class Code02_DFS {
+
+	public static void dfs(Node node) {
+		if (node == null) {
+			return;
+		}
+		Stack<Node> stack = new Stack<>();
+		HashSet<Node> set = new HashSet<>();
+		stack.add(node);
+		set.add(node);
+		System.out.println(node.value);
+		while (!stack.isEmpty()) {
+			Node cur = stack.pop();
+			for (Node next : cur.nexts) {
+				if (!set.contains(next)) {
+					stack.push(cur);
+					stack.push(next);
+					set.add(next);
+					System.out.println(next.value);
+					break;
+				}
+			}
+		}
+	}
+	
+	
+	
+
+}

src/class16/Code03_TopologicalOrderBFS.java

@@ -0,0 +1,53 @@
+package class16;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Queue;
+
+// OJ链接：https://www.lintcode.com/problem/topological-sorting
+public class Code03_TopologicalOrderBFS {
+
+	// 不要提交这个类
+	public static class DirectedGraphNode {
+		public int label;
+		public ArrayList<DirectedGraphNode> neighbors;
+
+		public DirectedGraphNode(int x) {
+			label = x;
+			neighbors = new ArrayList<DirectedGraphNode>();
+		}
+	}
+
+	// 提交下面的
+	public static ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
+		HashMap<DirectedGraphNode, Integer> indegreeMap = new HashMap<>();
+		for (DirectedGraphNode cur : graph) {
+			indegreeMap.put(cur, 0);
+		}
+		for (DirectedGraphNode cur : graph) {
+			for (DirectedGraphNode next : cur.neighbors) {
+				indegreeMap.put(next, indegreeMap.get(next) + 1);
+			}
+		}
+		Queue<DirectedGraphNode> zeroQueue = new LinkedList<>();
+		for (DirectedGraphNode cur : indegreeMap.keySet()) {
+			if (indegreeMap.get(cur) == 0) {
+				zeroQueue.add(cur);
+			}
+		}
+		ArrayList<DirectedGraphNode> ans = new ArrayList<>();
+		while (!zeroQueue.isEmpty()) {
+			DirectedGraphNode cur = zeroQueue.poll();
+			ans.add(cur);
+			for (DirectedGraphNode next : cur.neighbors) {
+				indegreeMap.put(next, indegreeMap.get(next) - 1);
+				if (indegreeMap.get(next) == 0) {
+					zeroQueue.offer(next);
+				}
+			}
+		}
+		return ans;
+	}
+
+}

src/class16/Code03_TopologicalOrderDFS1.java

@@ -0,0 +1,70 @@
+package class16;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+
+// OJ链接：https://www.lintcode.com/problem/topological-sorting
+public class Code03_TopologicalOrderDFS1 {
+
+	// 不要提交这个类
+	public static class DirectedGraphNode {
+		public int label;
+		public ArrayList<DirectedGraphNode> neighbors;
+
+		public DirectedGraphNode(int x) {
+			label = x;
+			neighbors = new ArrayList<DirectedGraphNode>();
+		}
+	}
+
+	// 提交下面的
+	public static class Record {
+		public DirectedGraphNode node;
+		public int deep;
+
+		public Record(DirectedGraphNode n, int o) {
+			node = n;
+			deep = o;
+		}
+	}
+
+	public static class MyComparator implements Comparator<Record> {
+
+		@Override
+		public int compare(Record o1, Record o2) {
+			return o2.deep - o1.deep;
+		}
+	}
+
+	public static ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
+		HashMap<DirectedGraphNode, Record> order = new HashMap<>();
+		for (DirectedGraphNode cur : graph) {
+			f(cur, order);
+		}
+		ArrayList<Record> recordArr = new ArrayList<>();
+		for (Record r : order.values()) {
+			recordArr.add(r);
+		}
+		recordArr.sort(new MyComparator());
+		ArrayList<DirectedGraphNode> ans = new ArrayList<DirectedGraphNode>();
+		for (Record r : recordArr) {
+			ans.add(r.node);
+		}
+		return ans;
+	}
+
+	public static Record f(DirectedGraphNode cur, HashMap<DirectedGraphNode, Record> order) {
+		if (order.containsKey(cur)) {
+			return order.get(cur);
+		}
+		int follow = 0;
+		for (DirectedGraphNode next : cur.neighbors) {
+			follow = Math.max(follow, f(next, order).deep);
+		}
+		Record ans = new Record(cur, follow + 1);
+		order.put(cur, ans);
+		return ans;
+	}
+
+}

src/class16/Code03_TopologicalOrderDFS2.java

@@ -0,0 +1,76 @@
+package class16;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+
+// OJ链接：https://www.lintcode.com/problem/topological-sorting
+public class Code03_TopologicalOrderDFS2 {
+
+	// 不要提交这个类
+	public static class DirectedGraphNode {
+		public int label;
+		public ArrayList<DirectedGraphNode> neighbors;
+
+		public DirectedGraphNode(int x) {
+			label = x;
+			neighbors = new ArrayList<DirectedGraphNode>();
+		}
+	}
+
+	// 提交下面的
+	public static class Record {
+		public DirectedGraphNode node;
+		public long nodes;
+
+		public Record(DirectedGraphNode n, long o) {
+			node = n;
+			nodes = o;
+		}
+	}
+
+	public static class MyComparator implements Comparator<Record> {
+
+		@Override
+		public int compare(Record o1, Record o2) {
+			return o1.nodes == o2.nodes ? 0 : (o1.nodes > o2.nodes ? -1 : 1);
+		}
+	}
+
+	public static ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
+		HashMap<DirectedGraphNode, Record> order = new HashMap<>();
+		for (DirectedGraphNode cur : graph) {
+			f(cur, order);
+		}
+		ArrayList<Record> recordArr = new ArrayList<>();
+		for (Record r : order.values()) {
+			recordArr.add(r);
+		}
+		recordArr.sort(new MyComparator());
+		ArrayList<DirectedGraphNode> ans = new ArrayList<DirectedGraphNode>();
+		for (Record r : recordArr) {
+			ans.add(r.node);
+		}
+		return ans;
+	}
+
+	// 当前来到cur点，请返回cur点所到之处，所有的点次！
+	// 返回（cur，点次）
+	// 缓存！！！！！order   
+	//  key : 某一个点的点次，之前算过了！
+	//  value : 点次是多少
+	public static Record f(DirectedGraphNode cur, HashMap<DirectedGraphNode, Record> order) {
+		if (order.containsKey(cur)) {
+			return order.get(cur);
+		}
+		// cur的点次之前没算过！
+		long nodes = 0;
+		for (DirectedGraphNode next : cur.neighbors) {
+			nodes += f(next, order).nodes;
+		}
+		Record ans = new Record(cur, nodes + 1);
+		order.put(cur, ans);
+		return ans;
+	}
+
+}

src/class16/Code03_TopologySort.java

@@ -0,0 +1,38 @@
+package class16;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Code03_TopologySort {
+
+	// directed graph and no loop
+	public static List<Node> sortedTopology(Graph graph) {
+
+		// key 某个节点   value 剩余的入度
+		HashMap<Node, Integer> inMap = new HashMap<>();
+		// 只有剩余入度为0的点，才进入这个队列
+		Queue<Node> zeroInQueue = new LinkedList<>();
+		for (Node node : graph.nodes.values()) {
+			inMap.put(node, node.in);
+			if (node.in == 0) {
+				zeroInQueue.add(node);
+			}
+		}
+		List<Node> result = new ArrayList<>();
+		while (!zeroInQueue.isEmpty()) {
+			Node cur = zeroInQueue.poll();
+			result.add(cur);
+			for (Node next : cur.nexts) {
+				inMap.put(next, inMap.get(next) - 1);
+				if (inMap.get(next) == 0) {
+					zeroInQueue.add(next);
+				}
+			}
+		}
+		return result;
+	}
+
+}

src/class16/Code04_Kruskal.java

@@ -0,0 +1,101 @@
+package class16;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.PriorityQueue;
+import java.util.Set;
+import java.util.Stack;
+
+//undirected graph only
+public class Code04_Kruskal {
+
+	// Union-Find Set
+	public static class UnionFind {
+		// key 某一个节点， value key节点往上的节点
+		private HashMap<Node, Node> fatherMap;
+		// key 某一个集合的代表节点, value key所在集合的节点个数
+		private HashMap<Node, Integer> sizeMap;
+
+		public UnionFind() {
+			fatherMap = new HashMap<Node, Node>();
+			sizeMap = new HashMap<Node, Integer>();
+		}
+		
+		public void makeSets(Collection<Node> nodes) {
+			fatherMap.clear();
+			sizeMap.clear();
+			for (Node node : nodes) {
+				fatherMap.put(node, node);
+				sizeMap.put(node, 1);
+			}
+		}
+
+		private Node findFather(Node n) {
+			Stack<Node> path = new Stack<>();
+			while(n != fatherMap.get(n)) {
+				path.add(n);
+				n = fatherMap.get(n);
+			}
+			while(!path.isEmpty()) {
+				fatherMap.put(path.pop(), n);
+			}
+			return n;
+		}
+
+		public boolean isSameSet(Node a, Node b) {
+			return findFather(a) == findFather(b);
+		}
+
+		public void union(Node a, Node b) {
+			if (a == null || b == null) {
+				return;
+			}
+			Node aDai = findFather(a);
+			Node bDai = findFather(b);
+			if (aDai != bDai) {
+				int aSetSize = sizeMap.get(aDai);
+				int bSetSize = sizeMap.get(bDai);
+				if (aSetSize <= bSetSize) {
+					fatherMap.put(aDai, bDai);
+					sizeMap.put(bDai, aSetSize + bSetSize);
+					sizeMap.remove(aDai);
+				} else {
+					fatherMap.put(bDai, aDai);
+					sizeMap.put(aDai, aSetSize + bSetSize);
+					sizeMap.remove(bDai);
+				}
+			}
+		}
+	}
+	
+
+	public static class EdgeComparator implements Comparator<Edge> {
+
+		@Override
+		public int compare(Edge o1, Edge o2) {
+			return o1.weight - o2.weight;
+		}
+
+	}
+
+	public static Set<Edge> kruskalMST(Graph graph) {
+		UnionFind unionFind = new UnionFind();
+		unionFind.makeSets(graph.nodes.values());
+		// 从小的边到大的边，依次弹出，小根堆！
+		PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
+		for (Edge edge : graph.edges) { // M 条边
+			priorityQueue.add(edge);  // O(logM)
+		}
+		Set<Edge> result = new HashSet<>();
+		while (!priorityQueue.isEmpty()) { // M 条边
+			Edge edge = priorityQueue.poll(); // O(logM)
+			if (!unionFind.isSameSet(edge.from, edge.to)) { // O(1)
+				result.add(edge);
+				unionFind.union(edge.from, edge.to);
+			}
+		}
+		return result;
+	}
+}

src/class16/Code05_Prim.java

@@ -0,0 +1,91 @@
+package class16;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.PriorityQueue;
+import java.util.Set;
+
+// undirected graph only
+public class Code05_Prim {
+
+	public static class EdgeComparator implements Comparator<Edge> {
+
+		@Override
+		public int compare(Edge o1, Edge o2) {
+			return o1.weight - o2.weight;
+		}
+
+	}
+
+	public static Set<Edge> primMST(Graph graph) {
+		// 解锁的边进入小根堆
+		PriorityQueue<Edge> priorityQueue = new PriorityQueue<>(new EdgeComparator());
+		// 哪些点被解锁出来了
+		HashSet<Node> nodeSet = new HashSet<>();
+
+		Set<Edge> result = new HashSet<>(); // 依次挑选的的边在result里
+
+		for (Node node : graph.nodes.values()) { // 随便挑了一个点
+			// node 是开始点
+			if (!nodeSet.contains(node)) {
+				nodeSet.add(node);
+				for (Edge edge : node.edges) { // 由一个点，解锁所有相连的边
+					priorityQueue.add(edge);
+				}
+				while (!priorityQueue.isEmpty()) {
+					Edge edge = priorityQueue.poll(); // 弹出解锁的边中，最小的边
+					Node toNode = edge.to; // 可能的一个新的点
+					if (!nodeSet.contains(toNode)) { // 不含有的时候，就是新的点
+						nodeSet.add(toNode);
+						result.add(edge);
+						for (Edge nextEdge : toNode.edges) {
+							priorityQueue.add(nextEdge);
+						}
+					}
+				}
+			}
+			// break;
+		}
+		return result;
+	}
+
+	// 请保证graph是连通图
+	// graph[i][j]表示点i到点j的距离，如果是系统最大值代表无路
+	// 返回值是最小连通图的路径之和
+	public static int prim(int[][] graph) {
+		int size = graph.length;
+		int[] distances = new int[size];
+		boolean[] visit = new boolean[size];
+		visit[0] = true;
+		for (int i = 0; i < size; i++) {
+			distances[i] = graph[0][i];
+		}
+		int sum = 0;
+		for (int i = 1; i < size; i++) {
+			int minPath = Integer.MAX_VALUE;
+			int minIndex = -1;
+			for (int j = 0; j < size; j++) {
+				if (!visit[j] && distances[j] < minPath) {
+					minPath = distances[j];
+					minIndex = j;
+				}
+			}
+			if (minIndex == -1) {
+				return sum;
+			}
+			visit[minIndex] = true;
+			sum += minPath;
+			for (int j = 0; j < size; j++) {
+				if (!visit[j] && distances[j] > graph[minIndex][j]) {
+					distances[j] = graph[minIndex][j];
+				}
+			}
+		}
+		return sum;
+	}
+
+	public static void main(String[] args) {
+		System.out.println("hello world!");
+	}
+
+}

src/class16/Code06_Dijkstra.java

@@ -0,0 +1,171 @@
+package class16;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map.Entry;
+
+// no negative weight
+public class Code06_Dijkstra {
+
+    public static HashMap<Node, Integer> dijkstra1(Node from) {
+        HashMap<Node, Integer> distanceMap = new HashMap<>();
+        distanceMap.put(from, 0);
+        // 打过对号的点
+        HashSet<Node> selectedNodes = new HashSet<>();
+        Node minNode = getMinDistanceAndUnselectedNode(distanceMap, selectedNodes);
+        while (minNode != null) {
+            //  原始点  ->  minNode(跳转点)   最小距离distance
+            int distance = distanceMap.get(minNode);
+            for (Edge edge : minNode.edges) {
+                Node toNode = edge.to;
+                if (!distanceMap.containsKey(toNode)) {
+                    distanceMap.put(toNode, distance + edge.weight);
+                } else { // toNode
+                    distanceMap.put(edge.to, Math.min(distanceMap.get(toNode), distance + edge.weight));
+                }
+            }
+            selectedNodes.add(minNode);
+            minNode = getMinDistanceAndUnselectedNode(distanceMap, selectedNodes);
+        }
+        return distanceMap;
+    }
+
+    public static Node getMinDistanceAndUnselectedNode(HashMap<Node, Integer> distanceMap, HashSet<Node> touchedNodes) {
+        Node minNode = null;
+        int minDistance = Integer.MAX_VALUE;
+        for (Entry<Node, Integer> entry : distanceMap.entrySet()) {
+            Node node = entry.getKey();
+            int distance = entry.getValue();
+            if (!touchedNodes.contains(node) && distance < minDistance) {
+                minNode = node;
+                minDistance = distance;
+            }
+        }
+        return minNode;
+    }
+
+    public static class NodeRecord {
+        public Node node;
+        public int distance;
+
+        public NodeRecord(Node node, int distance) {
+            this.node = node;
+            this.distance = distance;
+        }
+    }
+
+    /**
+     * 这里我们使用了Node数组，回想堆排序时候的堆，我们是一个int数组，因为现在是Node数组，所以我们不能直接根据Node来比较
+     * 所以这里我们需要一个distanceMap来提供一个比较的途径。然后因为我们还需要更新堆中的某一个结点，更改完之后需要调整，所以
+     * 这里我们还需要一个heapIndexMao，这个map有两个作用，一个是判断一个结点是否进入过堆中--通过index是否为-1判断。另外一个
+     * 作用就是得到一个结点在堆中的下标，这样方便我们调整。
+     */
+    public static class NodeHeap {
+        private Node[] nodes; // 实际的堆结构
+        // key 某一个node， value 上面堆中的位置.如果这里的位置为-1说明这结点曾经进来过但是现在不在堆上了。
+        private HashMap<Node, Integer> heapIndexMap;
+        // key 某一个节点， value 从源节点出发到该节点的目前最小距离
+        private HashMap<Node, Integer> distanceMap;
+        private int size; // 堆上有多少个点
+
+        public NodeHeap(int size) {
+            nodes = new Node[size];
+            heapIndexMap = new HashMap<>();
+            distanceMap = new HashMap<>();
+            size = 0;
+        }
+
+        public boolean isEmpty() {
+            return size == 0;
+        }
+
+        // 有一个点叫node，现在发现了一个从源节点出发到达node的距离为distance
+        // 判断要不要更新，如果需要的话，就更新
+        public void addOrUpdateOrIgnore(Node node, int distance) {
+            if (inHeap(node)) {
+                distanceMap.put(node, Math.min(distanceMap.get(node), distance));
+                insertHeapify(node, heapIndexMap.get(node));
+            }
+            if (!isEntered(node)) {
+                nodes[size] = node;
+                heapIndexMap.put(node, size);
+                distanceMap.put(node, distance);
+                insertHeapify(node, size++);
+            }
+        }
+
+        /**
+         * 这个方法是用来服务外面的Dijkstra函数的。Dijkstra需要的是结点和距离的一个二元组信息，所以这里我们把node和distance
+         * 封装在一起弹出给外面。
+         * @return
+         */
+        public NodeRecord pop() {
+            NodeRecord nodeRecord = new NodeRecord(nodes[0], distanceMap.get(nodes[0]));
+            swap(0, size - 1);
+            heapIndexMap.put(nodes[size - 1], -1);
+            distanceMap.remove(nodes[size - 1]);//这个结点以后不可能再进来了，所以可以放心的移出
+            // free C++同学还要把原本堆顶节点析构，对java同学不必
+            nodes[size - 1] = null;
+            heapify(0, --size);
+            return nodeRecord;
+        }
+
+        private void insertHeapify(Node node, int index) {
+            while (distanceMap.get(nodes[index]) < distanceMap.get(nodes[(index - 1) / 2])) {
+                swap(index, (index - 1) / 2);
+                index = (index - 1) / 2;
+            }
+        }
+
+        private void heapify(int index, int size) {
+            int left = index * 2 + 1;
+            while (left < size) {
+                int smallest = left + 1 < size && distanceMap.get(nodes[left + 1]) < distanceMap.get(nodes[left])
+                        ? left + 1
+                        : left;
+                smallest = distanceMap.get(nodes[smallest]) < distanceMap.get(nodes[index]) ? smallest : index;
+                if (smallest == index) {
+                    break;
+                }
+                swap(smallest, index);
+                index = smallest;
+                left = index * 2 + 1;
+            }
+        }
+
+        private boolean isEntered(Node node) {//判断一个结点是否进来过堆，不管是-1还是一些其它的值
+            return heapIndexMap.containsKey(node);
+        }
+
+        private boolean inHeap(Node node) {//一个结点进来过并且在位置不等于-1它就在堆上。
+            return isEntered(node) && heapIndexMap.get(node) != -1;
+        }
+
+        private void swap(int index1, int index2) {
+            heapIndexMap.put(nodes[index1], index2);
+            heapIndexMap.put(nodes[index2], index1);
+            Node tmp = nodes[index1];
+            nodes[index1] = nodes[index2];
+            nodes[index2] = tmp;
+        }
+    }
+
+    // 改进后的dijkstra算法
+    // 从head出发，所有head能到达的节点，生成到达每个节点的最小路径记录并返回
+    public static HashMap<Node, Integer> dijkstra2(Node head, int size) {
+        NodeHeap nodeHeap = new NodeHeap(size);
+        nodeHeap.addOrUpdateOrIgnore(head, 0);
+        HashMap<Node, Integer> result = new HashMap<>();
+        while (!nodeHeap.isEmpty()) {//从小跟堆里面弹一条记录我就加一条在result里面
+            NodeRecord record = nodeHeap.pop();
+            Node cur = record.node;
+            int distance = record.distance;
+            for (Edge edge : cur.edges) {
+                nodeHeap.addOrUpdateOrIgnore(edge.to, edge.weight + distance);
+            }
+            result.put(cur, distance);
+        }
+        return result;
+    }
+
+}

src/class16/Code06_NetworkDelayTime.java

@@ -0,0 +1,151 @@
+package class16;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// 课上没有讲这个题，这是我给同学们找的练习题
+// leetcode 743题，可以用这道题来练习Dijkstra算法
+// 测试链接 : https://leetcode.com/problems/network-delay-time
+public class Code06_NetworkDelayTime {
+
+	// 方法一 : 普通堆 + 屏蔽已经计算过的点
+	public static int networkDelayTime1(int[][] times, int n, int k) {
+		ArrayList<ArrayList<int[]>> nexts = new ArrayList<>();
+		for (int i = 0; i <= n; i++) {
+			nexts.add(new ArrayList<>());
+		}
+		for (int[] delay : times) {
+			nexts.get(delay[0]).add(new int[] { delay[1], delay[2] });
+		}
+		PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+		heap.add(new int[] { k, 0 });
+		boolean[] used = new boolean[n + 1];
+		int num = 0;
+		int max = 0;
+		while (!heap.isEmpty() && num < n) {
+			int[] record = heap.poll();
+			int cur = record[0];
+			int delay = record[1];
+			if (used[cur]) {
+				continue;
+			}
+			used[cur] = true;
+			num++;
+			max = Math.max(max, delay);
+			for (int[] next : nexts.get(cur)) {
+				heap.add(new int[] { next[0], delay + next[1] });
+			}
+		}
+		return num < n ? -1 : max;
+	}
+
+	// 方法二 : 加强堆的解法
+	public static int networkDelayTime2(int[][] times, int n, int k) {
+		ArrayList<ArrayList<int[]>> nexts = new ArrayList<>();
+		for (int i = 0; i <= n; i++) {
+			nexts.add(new ArrayList<>());
+		}
+		for (int[] delay : times) {
+			nexts.get(delay[0]).add(new int[] { delay[1], delay[2] });
+		}
+		Heap heap = new Heap(n);
+		heap.add(k, 0);
+		int num = 0;
+		int max = 0;
+		while (!heap.isEmpty()) {
+			int[] record = heap.poll();
+			int cur = record[0];
+			int delay = record[1];
+			num++;
+			max = Math.max(max, delay);
+			for (int[] next : nexts.get(cur)) {
+				heap.add(next[0], delay + next[1]);
+			}
+		}
+		return num < n ? -1 : max;
+	}
+
+	// 加强堆
+	public static class Heap {
+		public boolean[] used;
+		public int[][] heap;
+		public int[] hIndex;
+		public int size;
+
+		public Heap(int n) {
+			used = new boolean[n + 1];
+			heap = new int[n + 1][2];
+			hIndex = new int[n + 1];
+			Arrays.fill(hIndex, -1);
+			size = 0;
+		}
+
+		public void add(int cur, int delay) {
+			if (used[cur]) {
+				return;
+			}
+			if (hIndex[cur] == -1) {
+				heap[size][0] = cur;
+				heap[size][1] = delay;
+				hIndex[cur] = size;
+				heapInsert(size++);
+			} else {
+				int hi = hIndex[cur];
+				if (delay <= heap[hi][1]) {
+					heap[hi][1] = delay;
+					heapInsert(hi);
+				}
+			}
+		}
+
+		public int[] poll() {
+			int[] ans = heap[0];
+			swap(0, --size);
+			heapify(0);
+			used[ans[0]] = true;
+			hIndex[ans[0]] = -1;
+			return ans;
+		}
+
+		public boolean isEmpty() {
+			return size == 0;
+		}
+
+		private void heapInsert(int i) {
+			int parent = (i - 1) / 2;
+			while (heap[i][1] < heap[parent][1]) {
+				swap(i, parent);
+				i = parent;
+				parent = (i - 1) / 2;
+			}
+		}
+
+		private void heapify(int i) {
+			int l = (i * 2) + 1;
+			while (l < size) {
+				int smallest = l + 1 < size && heap[l + 1][1] < heap[l][1] ? (l + 1) : l;
+				smallest = heap[smallest][1] < heap[i][1] ? smallest : i;
+				if (smallest == i) {
+					break;
+				}
+				swap(smallest, i);
+				i = smallest;
+				l = (i * 2) + 1;
+			}
+		}
+
+		private void swap(int i, int j) {
+			int[] o1 = heap[i];
+			int[] o2 = heap[j];
+			int o1hi = hIndex[o1[0]];
+			int o2hi = hIndex[o2[0]];
+			heap[i] = o2;
+			heap[j] = o1;
+			hIndex[o1[0]] = o2hi;
+			hIndex[o2[0]] = o1hi;
+		}
+
+	}
+
+}