arr[j]) {
+ //这个公式你要品，你细品
+ dp[i] = Math.max(dp[i], dp[j] + 1);
+ }
+ }
+ }
+
+ System.out.println(Arrays.toString(dp));
+
+ int max = 0;
+ int maxIndex = 0;
+ //找到最大值
+ for (int k = dp.length - 1; k >= 0; k--) {
+ if (dp[k] > max) {
+ max = dp[k];
+ maxIndex = k;
+ }
+ }
+
+ System.out.println("max=" + max + "maxIndex=" + maxIndex);
+ System.out.println(arr[maxIndex]);
+ for (int m = maxIndex; m >= 0; m--) {
+ if (arr[m] < arr[maxIndex] && dp[m] == dp[maxIndex] - 1) {
+ maxIndex = m;
+ System.out.println(arr[m]);
+ }
+ }
+ }
+
+ // O N*N; 通过二分查找优化成Ologn
+
+ /**
+ * 通过递增子串的规则，我们发现
+ *
+ * 每次我们都找一个最小
+ *
+ * @param arr
+ */
+ private static void findTwoSplit(int[] arr) {
+ //存储第i个位置结尾，最长递增子串长度
+
+ //根据最后一个dp 值向前遍历，找打小于他的一个值，并且dp[i] = dp[7]-1
+
+ int dp[] = new int[arr.length];
+ //有效值
+ int ends[] = new int[arr.length];
+ ends[0] = arr[0];
+ dp[0] = 1;
+ // 0 right有效区
+ int right = 0;
+ for (int i = 1; i < arr.length; i++) {
+ int l = 0;
+ int r = right;
+ while (l <= r) {
+ int mid = (l + r) / 2;
+ if (arr[i] > ends[mid]) {
+ l = mid + 1;
+ } else {
+ r = mid - 1;
+ }
+ }
+ if (l > right) {//有效区扩张
+ right = l;
+ }
+ ends[l] = arr[i];
+ dp[i] = l + 1;
+
+// for (int j = 0; j < i; j++) {
+// //与前面每一个比较如果大于就比较一下对应dp值是否是最大的赋值给当前
+// if (arr[i] > arr[j]) {
+// //这个公式你要品，你细品
+// dp[i] = Math.max(dp[i], dp[j] + 1);
+// }
+// }
+ }
+
+ System.out.println(Arrays.toString(dp));
+
+ int max = 0;
+ int maxIndex = 0;
+ //找到最大值
+ for (int k = dp.length - 1; k >= 0; k--) {
+ if (dp[k] > max) {
+ max = dp[k];
+ maxIndex = k;
+ }
+ }
+
+ System.out.println("max=" + max + "maxIndex=" + maxIndex);
+ System.out.println(arr[maxIndex]);
+ for (int m = maxIndex; m >= 0; m--) {
+ if (arr[m] < arr[maxIndex] && dp[m] == dp[maxIndex] - 1) {
+ maxIndex = m;
+ System.out.println(arr[m]);
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubSequence.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubSequence.java
new file mode 100644
index 0000000..1680018
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubSequence.java
@@ -0,0 +1,78 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class DynamicMaxLongSubSequence {
+
+ public static void main(String[] args) {
+
+ String str1 = "1A2C3D4B56";
+
+ String str2 = "B1D23CA45B6A";
+
+
+ String maxLongsubSequence = getMaxLongSubSequence(str1, str2);
+
+ System.out.println(maxLongsubSequence);
+ }
+
+ private static String getMaxLongSubSequence(String str1, String str2) {
+
+
+ char[] charArray1 = str1.toCharArray();
+ char[] charArray2 = str2.toCharArray();
+
+ int[][] dp = new int[str1.length()][str2.length()];
+
+ dp[0][0] = (charArray1[0] == charArray2[0] ? 1 : 0);
+
+ //填充第一行
+ for (int i = 1; i < str1.length(); i++) {
+ int count = (charArray1[i] == charArray2[0] ? 1 : 0);
+ dp[i][0] = Math.max(dp[i - 1][0], count);
+ }
+ //填充第一列
+ for (int j = 1; j < str2.length(); j++) {
+ int count = (charArray1[0] == charArray2[j] ? 1 : 0);
+ dp[0][j] = Math.max(dp[0][j - 1], count);
+ }
+
+ for (int i = 1; i < str1.length(); i++) {
+ for (int j = 1; j < str2.length(); j++) {
+ //去除两边最大值
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ if (charArray1[i] == charArray2[j]) {
+ //相等 并不是直接增加1 ,因为前面有可能增加过，所以要和前一行前一列的值+1比较
+ dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - 1] + 1);
+ }
+ }
+ }
+
+ int m = str1.length() - 1;
+ int n = str2.length() - 1;
+ //获取子序列
+ char[] res = new char[dp[str1.length() - 1][str2.length() - 1]];
+
+ int index = res.length - 1;
+ while (index >= 0) {
+ if (n > 0 && dp[m][n] == dp[m][n - 1]) {
+ n--;
+ } else if (m > 0 && dp[m][n] == dp[m - 1][n]) {
+ m--;
+ } else {
+ res[index--] = charArray1[m];
+ m--;
+ n--;
+ }
+ }
+ return Arrays.toString(res);
+ }
+
+}
+
+
+
+
+
+
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubString.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubString.java
new file mode 100644
index 0000000..b2b8223
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMaxLongSubString.java
@@ -0,0 +1,105 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+
+public class DynamicMaxLongSubString {
+
+ public static void main(String[] args) {
+
+ String str1 = "1AB2345CD";
+
+ String str2 = "12345EF";
+
+
+ String maxLongsubSequence = getMaxLongSubString(str1, str2);
+
+ System.out.println(maxLongsubSequence);
+ }
+
+ /**
+ * 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1
+ * 1 1 1 1 1 1 1
+ * 1 1 2 2 2 2 2
+ * 1 1 2 3 3 3 3
+ * 1 1 2 3 4 4 4
+ * 1 1 2 3 4 4 4
+ * 1 1 2 3 4 4 4
+ * [2, 3, 4, 5]
+ *
+ * @param str1
+ * @param str2
+ * @return
+ */
+ private static String getMaxLongSubString(String str1, String str2) {
+
+
+ char[] charArray1 = str1.toCharArray();
+ char[] charArray2 = str2.toCharArray();
+
+ int[][] dp = new int[str1.length()][str2.length()];
+
+ dp[0][0] = (charArray1[0] == charArray2[0] ? 1 : 0);
+
+ //填充第一行
+ for (int i = 1; i < str1.length(); i++) {
+ int count = (charArray1[i] == charArray2[0] ? 1 : 0);
+ dp[i][0] = Math.max(dp[i - 1][0], count);
+ }
+ //填充第一列
+ for (int j = 1; j < str2.length(); j++) {
+ int count = (charArray1[0] == charArray2[j] ? 1 : 0);
+ dp[0][j] = Math.max(dp[0][j - 1], count);
+ }
+
+ for (int i = 1; i < str1.length(); i++) {
+ for (int j = 1; j < str2.length(); j++) {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+ if (charArray1[i] == charArray2[j]
+ && charArray1[i - 1] == charArray2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + 1;
+ }
+ }
+ }
+ printArray(dp, str1.length(), str2.length());
+ char resultArray[] = new char[dp[str1.length() - 1][str2.length() - 1]];
+ int i = resultArray.length - 1;
+
+
+ for (int j = str1.length() - 1; j > 0; j--) {
+ int a = dp[j][str2.length() - 1];
+ int b = dp[j - 1][str2.length() - 1];
+ if (a > b) {
+ resultArray[i--] = charArray1[j];
+ }
+ if (i == 0 && a <= b) {
+ resultArray[i--] = charArray1[j];
+ }
+ if (i < 0) {
+ break;
+ } else {
+ continue;
+ }
+ }
+
+
+ return Arrays.toString(resultArray);
+ }
+
+
+ private static void printArray(int[][] m, int l1, int l2) {
+ for (int i = 0; i < l1; i++) {
+ for (int j = 0; j < l2; j++) {
+ System.out.print(m[i][j] + " ");
+ }
+ System.out.println();
+ }
+ }
+}
+
+
+
+
+
+
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoney.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoney.java
new file mode 100644
index 0000000..b093feb
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoney.java
@@ -0,0 +1,200 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class DynamicMoney {
+
+ public static void main(String[] args) {
+ Integer m[] = new Integer[]{5, 2, 3};
+
+ int mInt[] = new int[]{5, 2, 3};
+ //由大到小排序，效率更高
+ Arrays.sort(m, Collections.reverseOrder());
+
+// int curMoney = 20;//4
+// int curMoney = 19; // 5 5 5 2 2
+ int curMoney = 18; // 5 5 5 3
+
+// int count = splitMoney(m, 0, curMoney);
+ int count = minConins3(mInt, curMoney);
+ System.out.println("count=" + count);
+ }
+
+ /**
+ * 思路就是遍历逐个遍历，使用 0 张 1 ，2 张直到最大
+ *
+ * @param m
+ * @param index
+ * @param curMoney
+ * @return
+ */
+ private static int splitMoney(Integer[] m, int index, int curMoney) {
+ //都遍历完了，也得到了最小值
+ if (curMoney == 0) {
+ return 0;
+ }
+
+ /**
+ * 回溯当前Size
+ */
+ int currentSize = -1;
+ /**
+ * 遍历每一个元素，从不选，到选择最大
+ */
+ for (int i = index; i < m.length; i++) {
+ if (curMoney >= m[i]) {
+ int maxSelect = curMoney / m[i];//最大选择
+ //从0开始 j 就是选择张数
+ for (int j = 0; j <= maxSelect; j++) {
+ int restMoney = curMoney - m[i] * j;
+ int next = splitMoney(m, i + 1, restMoney);
+
+ if (next != -1) {//有解
+ if (currentSize == -1) {
+ //一次没有被回溯直接赋值,这里是i 加一，不是index +1
+ currentSize = j + next;
+ } else {
+ currentSize = Math.min(currentSize, j + next);
+ }
+ } else {
+ if (restMoney == 0) {
+ currentSize = j;
+ }
+ }
+ }
+ }
+ }
+ return currentSize;
+ }
+
+ public int minCoins1(int[] arr, int aim) {
+ if (arr == null || arr.length == 0 || aim < 0) {
+ return -1;
+ }
+ return process(arr, 0, aim);
+ }
+
+ /**
+ * 优化两层循环合并成一层 ，因为循环不是每次都从0开始，后续的遍历不涉及到前面
+ *
+ * @param arr
+ * @param i
+ * @param rest
+ * @return
+ */
+ private int process(int[] arr, int i, int rest) {
+ if (i == arr.length) {
+ return rest == 0 ? 0 : -1;
+ }
+
+ int count = -1;
+
+ for (int k = 0; k * arr[i] <= rest; k++) {
+ int next = process(arr, i + 1, rest - k * arr[i]);
+ if (next != -1) {
+ count = count == -1 ? next + k : Math.min(count, next + k);
+ }
+ }
+ return count;
+ }
+
+
+ /**
+ * 动态规划最优实现方案
+ * @param arr
+ * @param aim
+ * @return
+ */
+ public static int minConins2(int[] arr, int aim) {
+ if (arr == null || arr.length == 0 || aim < 0) {
+ return -1;
+ }
+ int N = arr.length;
+ int[][] dp = new int[N + 1][aim + 1];
+ //设置最后一排的值，除dp[N][0]外，其他都是-1
+
+ for (int col = 1; col <= aim; col++) {
+ dp[N][col] = -1;
+ }
+ for (int i = N - 1; i >= 0; i--) {//从底向上计算每一行
+ for (int rest = 0; rest <= aim; rest++) {
+ dp[i][rest] = -1;//初始时先设置dp[i][rest]的值无效
+ if (dp[i + 1][rest] != -1) {//下面的值如果有效
+ dp[i][rest] = dp[i + 1][rest];//先设置成下面的值
+ }
+ if (rest - arr[i] >= 0 && dp[i][rest - arr[i]] != -1) {
+ if (dp[i][rest] == -1) {
+ dp[i][rest] = dp[i][rest - arr[i]] + 1;
+ } else {
+ dp[i][rest] = Math.min(dp[i][rest], dp[i][rest - arr[i]] + 1);
+ }
+ }
+ }
+
+ }
+ printArray(dp);
+ return dp[0][aim];
+ }
+
+ /**
+ * 动态规划普通方案
+ * @param arr
+ * @param aim
+ * @return
+ */
+ public static int minConins3(int[] arr, int aim) {
+ if (arr == null || arr.length == 0 || aim < 0) {
+ return -1;
+ }
+ int N = arr.length;
+ int[][] dp = new int[N + 1][aim + 1];
+ //设置最后一排的值，除dp[N][0]外，其他都是-1
+
+ //最后一排为溢出所以都为-1无解
+ for (int col = 1; col <= aim; col++) {
+ dp[N][col] = -1;
+ }
+ for (int i = N - 1; i >= 0; i--) {//从底向上计算每一行
+ for (int rest = 0; rest <= aim; rest++) {
+ singleDataCalculate(arr[i], dp, i, rest);
+ }
+ }
+ printArray(dp);//测试打印
+ return dp[0][aim];
+ }
+
+ //这个可以优化
+ //把所有等式列出来发现 dp[i][rest] = Math.min(dp[i][rest], dp[i][rest - arr[i]] + 1);
+ private static void singleDataCalculate(int i, int[][] dp, int i2, int rest) {
+ dp[i2][rest] = -1;//初始时先设置dp[i][rest]的值无效
+ int k = rest / i2;//可试的最大张数
+ if (rest == 0) {//如果0表示不需要找钱 也就需要0张
+ dp[i2][rest] = 0;
+ } else {
+ int minValue = -1;//记录最小值
+ for (int j = 0; j <= k; j++) {
+ int next = dp[i2 + 1][rest - j * i2];
+ if (next != -1) {//-1表示无解不记录统计
+ if (minValue == -1) {//第一次统计，无需比较直接赋值
+ minValue = next + j;
+ } else {
+ minValue = Math.min(minValue, next + j);
+ }
+ }
+ }
+ dp[i2][rest] = minValue;
+ }
+ }
+
+ private static void printArray(int[][] m) {
+ for (int i = 0; i < 4; i++) {
+ for (int j = 0; j < 19; j++) {
+ System.out.print(m[i][j] + " ");
+ }
+ System.out.println();
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoneyWays.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoneyWays.java
new file mode 100644
index 0000000..3137f73
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicMoneyWays.java
@@ -0,0 +1,100 @@
+package com.wangpos.datastructure.algorithm;
+
+public class DynamicMoneyWays {
+
+ public static void main(String[] args) {
+
+ int arr[] = new int[]{5, 1};
+
+ int aim = 15;
+ /***
+ * 5
+ * 55
+ * 555
+ * 11111111
+ *
+ * 10 5
+ * 10 1 1 1 1 1
+ *
+ */
+// int aim = 1000;
+
+// int result = coin(arr, 0, aim);
+ int result = coin2(arr, aim);
+ System.out.println(result);
+ }
+
+ private static int coin(int[] arr, int index, int aim) {
+ if (index == arr.length) {
+ return 0;
+ }
+ int count = 0;
+ int maxUse = 0;
+ //找到小于当前面值的元素
+ for (int i = index; i < arr.length; i++) {
+ maxUse = aim / arr[i];
+ if (maxUse != 0) {
+ index = i;
+ break;
+ }
+ }
+
+ if (maxUse != 0) {//表示没有越界
+ for (int j = 0; j <= maxUse; j++) {
+ int rest = aim - j * arr[index];
+ if (rest == 0) {//有解
+ count += 1;
+ } else {//无解，遍历下一个
+ int next = coin(arr, index + 1, rest);
+ if (next != 0) {//等于0无解
+ count += next;
+ }
+ }
+ }
+ }
+ return count;
+ }
+
+ /**
+ * 动态规划方法
+ * @param arr
+ * @param aim
+ * @return
+ */
+ private static int coin2(int[] arr, int aim) {
+ int dp[][] = new int[arr.length + 1][aim + 1];
+ for (int i = 0; i <= arr.length; i++) {
+ dp[i][0] = 1;
+ }
+
+ int N = arr.length - 1;
+ for (int i = N; i >= 0; i--) {
+ for (int j = 1; j <= aim; j++) {
+ int maxValue = j / arr[i];
+ if (maxValue == 0) {
+ continue;//无效
+ }
+ int count = 0;
+ for (int k = 0; k <= maxValue; k++) {
+ int before = dp[i + 1][j - k * arr[i]];
+ count += before;
+ }
+ dp[i][j] = count;
+
+ }
+ }
+
+ printArray(dp);
+ return dp[0][aim];
+ }
+
+
+ private static void printArray(int[][] m) {
+ for (int i = 0; i < 3; i++) {
+ for (int j = 0; j < 16; j++) {
+ System.out.print(m[i][j] + " ");
+ }
+ System.out.println();
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicNestLetter.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicNestLetter.java
new file mode 100644
index 0000000..e68f0f9
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicNestLetter.java
@@ -0,0 +1,92 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class DynamicNestLetter {
+
+ public static void main(String[] args) {
+ int arr[][] = new int[][]{{3, 4}, {2, 3}, {4, 5}, {1, 3}, {2, 2}, {3, 6}, {1, 2}, {3, 2}, {2, 4}};
+ // int arr[][] = new int[][]{{3, 4}, {2, 3}, {4, 5}, {1, 3}, {2, 2}, {3, 6}};
+
+ int result = calculateTwoSplit(getSortedEnvelopes(arr));
+ System.out.println(result);
+ }
+
+ /**
+ * 将数组按照按照长度排序，然后求宽度的最长增长子串
+ *
+ * 。为什么呢？这与我们的排序策略有关，按照长度从小到大排序，长度相等的信封之间按照宽度从大到小排序。
+ *
+ * @param arr
+ * @return
+ */
+ private static int calculateTwoSplit(Envelope[] arr) {
+
+ //存储第i个位置结尾，最长递增子串长度
+
+ //根据最后一个dp 值向前遍历，找打小于他的一个值，并且dp[i] = dp[7]-1
+
+ int dp[] = new int[arr.length];
+ //有效值
+ int ends[] = new int[arr.length];
+ ends[0] = arr[0].wid;
+ dp[0] = 1;
+ // 0 right有效区
+ int right = 0;
+ for (int i = 1; i < arr.length; i++) {
+ int l = 0;
+ int r = right;
+ while (l <= r) {
+ int mid = (l + r) / 2;
+ if (arr[i].wid > ends[mid]) {
+ l = mid + 1;
+ } else {
+ r = mid - 1;
+ }
+ }
+ if (l > right) {//有效区扩张
+ right = l;
+ }
+ ends[l] = arr[i].wid;
+ dp[i] = l + 1;
+
+ }
+
+ return right + 1;
+
+ }
+
+ //这个排序数组，我们长度是按小到大，所以只需要看宽度的递增子序列即可
+ public static Envelope[] getSortedEnvelopes(int[][] matrix) {
+ Envelope[] res = new Envelope[matrix.length];
+ for (int i = 0; i < matrix.length; i++) {
+ res[i] = new Envelope(matrix[i][0], matrix[i][1]);
+ }
+ Arrays.sort(res, new EnvelopeComparator());
+ return res;
+ }
+
+}
+
+class Envelope {
+ public int len;
+ public int wid;
+
+ public Envelope(int weight, int hight) {
+ len = weight;
+ wid = hight;
+ }
+}
+
+class EnvelopeComparator implements Comparator {
+ @Override
+ public int compare(Envelope o1, Envelope o2) {
+ return o1.len != o2.len ? o1.len - o2.len : o2.wid - o1.wid;
+ }
+}
+
+
+
+
+
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicRobert.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicRobert.java
new file mode 100644
index 0000000..9999c2d
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicRobert.java
@@ -0,0 +1,81 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class DynamicRobert {
+
+ private static int N = 7;
+ private static int K = 10;//这里步骤要+1
+ private static int P = 4;//这里数组-1
+
+ public static void main(String[] args) {
+
+ int dp[][] = new int[K][N];
+
+ int result = way(dp);
+
+ System.out.println("result="+result);
+
+ printArray(dp);
+ }
+
+ private static int way(int[][] dp) {
+ dp[0][P] = 1;
+ for (int i = 1; i < K; i++) {
+ dp[i][0] = dp[i][0] + dp[i - 1][1];
+ dp[i][N - 1] = dp[i][N - 1] + dp[i - 1][N - 2];
+ for (int j = 1; j < N - 1; j++) {
+ dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
+ }
+ }
+
+ return dp[9][3];
+ }
+
+
+ private static void printArray(int[][] m) {
+ for (int i = 0; i < K; i++) {
+ for (int j = 0; j < N; j++) {
+ System.out.print(m[i][j] + " ");
+ }
+ System.out.println();
+ }
+
+ }
+
+ public int ways1(int N, int M, int K, int P) {
+ if (N < 2 || K < 1 || M < 1 || M > N || P < 1 || P > N) {
+ return 0;
+ }
+ return walk(N, M, K, P);
+ }
+
+
+ /**
+ * @param N 位置1~N
+ * @param cur 当前位置 可变参数
+ * @param rest 剩余步骤 可变参数
+ * @param P 最终目标位置P
+ * @return 表示解法数量
+ */
+ public int walk(int N, int cur, int rest, int P) {
+
+ if (rest == 0) {
+ return cur == P ? 1 : 0;
+ }
+
+ if (cur == 1) {
+ return walk(N, 2, rest - 1, P);
+ }
+
+ if (cur == N) {
+ return walk(N, N - 1, rest - 1, P);
+ }
+
+ return walk(N, cur + 1, rest - 1, P) + walk(N, cur - 1, rest - 1, P);
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicShootBalloon.java b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicShootBalloon.java
new file mode 100644
index 0000000..f600b7b
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/DynamicShootBalloon.java
@@ -0,0 +1,33 @@
+package com.wangpos.datastructure.algorithm;
+
+public class DynamicShootBalloon {
+
+ public static void main(String[] args) {
+
+ int[] arr = new int[]{3, 2, 5};
+
+// int result = shoot(arr, 0, 1);
+
+
+ }
+
+// private static int shoot(int[] arr, int l, int r) {
+//
+// int score = 0;
+// if (l >= 0) {
+// int cv = arr[l];
+// int lv = 1;
+// int rv = 1;
+// if (l - 1 >= 0) {
+// lv = arr[l - 1];
+// }
+// if (r < arr.length) {
+// rv = arr[r];
+// }
+// score = lv * cv * rv;
+// }
+//
+//
+// return 0
+// }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/NEmpress.java b/app/src/main/java/com/wangpos/datastructure/algorithm/NEmpress.java
new file mode 100644
index 0000000..5597c9c
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/NEmpress.java
@@ -0,0 +1,69 @@
+package com.wangpos.datastructure.algorithm;
+
+public class NEmpress {
+
+ public static void main(String[] args) {
+ // 4 == 2
+ // 1 == 1
+ // 2 3 == 0
+
+ // 8 ==92
+ Queen queen = new Queen(5);
+ queen.backtrack(1);
+ }
+
+}
+
+
+ class Queen {
+ private int[] column; //同栏是否有皇后，1表示有
+ private int[] rup; //右上至左下是否有皇后
+ private int[] lup; //左上至右下是否有皇后
+ private int[] queen; //解答
+ private int num; //解答编号
+ private int n = 1;
+
+ public Queen(int N) {
+ this.n = N;
+ column = new int[n+1];
+ rup = new int[(2*n)+1];
+ lup = new int[(2*n)+1];
+ for (int i = 1; i <= n; i++)
+ column[i] = 0;
+ for (int i = 1; i <= (2*n); i++)
+ rup[i] = lup[i] = 0; //初始定义全部无皇后
+ queen = new int[n+1];
+ }
+
+ public void backtrack(int i) {
+ if (i > n) {
+ showAnswer();
+ } else {
+ for (int j = 1; j <= n; j++) {
+ if ((column[j] == 0) && (rup[i+j] == 0) && (lup[i-j+n] == 0)) {
+ //若无皇后
+ queen[i] = j; //设定为占用
+ column[j] = rup[i+j] = lup[i-j+n] = 1;
+ backtrack(i+1); //循环调用
+ column[j] = rup[i+j] = lup[i-j+n] = 0;
+ }
+ }
+ }
+ }
+
+ protected void showAnswer() {
+ num++;
+ System.out.println("\n解答" + num);
+ for (int y = 1; y <= n; y++) {
+ for (int x = 1; x <= n; x++) {
+ if(queen[y]==x) {
+ System.out.print("Q");
+ } else {
+ System.out.print(".");
+ }
+ }
+ System.out.println();
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringAnagram.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringAnagram.java
new file mode 100644
index 0000000..418cba9
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringAnagram.java
@@ -0,0 +1,56 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringAnagram {
+
+ public static void main(String[] args) {
+ String targetString1 = "abcee";
+ String targetString2 = "bcdea";
+
+ boolean result = isDeformation(targetString1, targetString2);
+
+ System.out.println("结果：" + result);
+
+ }
+
+ /**
+ * 为什么要创建256个长度数组
+ *
+ * ASCII编码表中一共有256个字符
+ *
+ * 前128个为常用的字符 如 运算符 字母 数字等 键盘上可以显示的
+ * 后 128个为 特殊字符 是键盘上找不到的字符
+ *
+ * // 为什么有小于0 就是false,
+ * //首先前提我们判断过是长度相等的
+ * //如果chas1 中种类多和chas1种类数量不一样，就一定会出现负数，
+ * //出现负数有两种，第一种是种类多的变为负数，第二种是没有的变为负数
+ * @param targetString1
+ * @param targetString2
+ * @return
+ */
+ private static boolean isDeformation(String targetString1,
+ String targetString2) {
+ if (targetString1 == null || targetString2 == null
+ || targetString1.length() != targetString2.length()
+ ) {
+ return false;
+ }
+
+ char[] chas1 = targetString1.toCharArray();
+ char[] chars2 = targetString2.toCharArray();
+ //
+ int[] map = new int[256];
+
+ for (char c : chas1) {
+ map[c]++;
+ }
+ for (char c2 : chars2) {
+ map[c2]--;
+ if (map[c2] < 0) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringArraySearchString.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringArraySearchString.java
new file mode 100644
index 0000000..ec7f83b
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringArraySearchString.java
@@ -0,0 +1,51 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringArraySearchString {
+
+ public static void main(String args[]) {
+ String str = "a";
+
+ String[] strArrays = new String[]{null, "a", null, "a", null, "b", null, "c"};
+
+ System.out.println(getIndex(strArrays, str));
+ }
+
+ //二分法查找，
+ private static int getIndex(String[] strs, String str) {
+ if (strs == null || strs.length == 0 || str == null) {
+ return -1;
+ }
+ int res = -1;
+ int left = 0;
+ int right = strs.length - 1;
+ int mid = 0;
+ int i = 0;
+
+ while (left < right) {
+ mid = (left + right) / 2;
+ if (strs[mid] != null && strs[mid].equals(str)) {
+ res = mid;//返回最左边,所以要继续遍历
+ right = mid - 1;
+ } else if (strs[mid] != null) {
+ if (strs[mid].compareTo(str) < 0) {
+ left = mid + 1;
+ } else {
+ right = mid - 1;
+ }
+ } else {
+ i = mid;
+ while (strs[i] == null && --i >= left) ;
+
+ if (i < left || strs[i].compareTo(str) < 0) {
+ left = mid + 1;
+ } else {
+ res = strs[i].equals(str) ? i : res;
+ right = i - 1;
+ }
+ }
+ }
+
+
+ return res;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringBracketStringInValid.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringBracketStringInValid.java
new file mode 100644
index 0000000..516f8cd
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringBracketStringInValid.java
@@ -0,0 +1,79 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+import java.util.Stack;
+
+public class StringBracketStringInValid {
+
+ public static void main(String[] args) {
+
+ String str = "()()()";
+ String str2 = "((()()(()(";
+ String str3 = "121()()()";
+ System.out.println("result=" + inValidBracketString(str));
+ System.out.println("result=" + inValidBracketString(str3));
+
+ String str4 = "())";
+
+ String str5 = "()(()()(";
+
+ System.out.println(maxLengthBrcketString(str4));
+
+ System.out.println(maxLengthBrcketString(str5));
+ }
+
+ public static boolean inValidBracketString(String origin) {
+ char[] arrays = origin.toCharArray();
+ Stack stack = new Stack();
+
+ for (char data : arrays) {
+ if (data != '(' && data != ')') {
+ return false;
+ }
+ if (stack.isEmpty()) {
+ stack.push(data);
+ } else {
+ char top = stack.peek();
+ if (top == '(' && data == ')') {
+ stack.pop();
+ } else {
+ stack.push(data);
+ }
+ }
+ }
+
+ if (stack.isEmpty()) {
+ return true;
+ }
+ return false;
+ }
+
+
+ public static int maxLengthBrcketString(String origin) {
+ char[] arrays = origin.toCharArray();
+ int length = arrays.length;
+ int dp[] = new int[length];
+ //dp的值代表以当前结尾最长有效子串长度，什么意思？ 比如（)( dp[0]=0 dp[1]=2 dp[2] = 0
+ //（这里我会有疑问，我们以为dp[2]= 2 其实不是
+ // (() dp[2] = 2 如果结尾是） 从后向前找有效数量
+ // ()(() dp[4] = 2 从后向前找到
+ //()(()() dp[6] = 4 pre = 5 pre-1 = 4 dp[pre-1] = 2
+ //()()) dp[4] = 0
+ dp[0] = 0;
+ int pre = 0;
+ int res = 0;
+ for (int i = 1; i < arrays.length; i++) {
+ if (arrays[i] == ')') {
+ pre = i - dp[i - 1] - 1;
+ if (pre >= 0 && arrays[pre] == '(') {
+ //()(()())
+ dp[i] = dp[i - 1] + 2 + (pre > 0 ? dp[pre - 1] : 0);
+ }
+ }
+ res = Math.max(res, dp[i]);
+ }
+ System.out.println(Arrays.toString(dp));
+ return res;
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringContactMinDictionaryRank.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringContactMinDictionaryRank.java
new file mode 100644
index 0000000..eee0241
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringContactMinDictionaryRank.java
@@ -0,0 +1,37 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+
+/**
+ * 排序比较就可以了，重要的是排序条件
+ */
+public class StringContactMinDictionaryRank {
+
+ public static void main(String[] args) {
+ String[] strArray = new String[]{"abc", "bcd", "acd"};
+
+ System.out.println(lowString(strArray));
+
+ }
+
+ public static class MyComparator implements Comparator{
+ @Override
+ public int compare(String o1, String o2) {
+ return (o1+02).compareTo(o2+o1);
+ }
+ }
+ public static String lowString(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;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringFormulaCalculate.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringFormulaCalculate.java
new file mode 100644
index 0000000..9894ef4
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringFormulaCalculate.java
@@ -0,0 +1,213 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * 支持整数加减乘除公式
+ */
+public class StringFormulaCalculate {
+
+ public static void main(String[] args) {
+ /**
+ * 加减法计算
+ */
+ String formula = "1+2-1+5-6";
+ /**
+ * 加减乘
+ */
+ String formula1 = "1+2*3"; //7
+ String formula2 = "1+2*3+4"; //11
+// String formula3 = "1*2+3+4"; //9
+ String formula4 = "1-2+3*4+6/2";//14
+
+ String formula5 = "2*(4-2)+5";
+
+ String formula6 = "2*(4-2)";
+
+ String formula7 = "(4-2)*2";
+ String formula8 = "10*((5-2)-2)";
+ String formula9 = "48*((70-65)-43)+8*1";
+// String formula = "48*((70-65)-43)+8*1";
+// String formula = "48*((70-65)-43)+8*1";
+
+// calculate(formula1, 0);
+// calculate(formula2, 0);
+// calculate(formula3, 0);
+// calculate(formula4,0);
+ calculate(formula9, 0);
+ Deque queues2 = queues;
+ System.out.println("结果" + queues);
+ }
+
+ /**
+ * 存储 数字和运算符
+ */
+ private static Deque queues = new LinkedList<>();
+
+ private static void addLastNum(Integer cur) {
+ String curNum = cur.toString();
+ if (queues.size() > 1) {
+ String sign = queues.removeLast();
+ String prev = queues.removeLast();
+ int result = calculateExpress(prev, curNum, sign);
+ queues.add(String.valueOf(result));
+ } else {
+ queues.add(curNum);
+ }
+ if (queues.size() > 1) {
+ String last = queues.removeLast();
+ addLastNum(Integer.valueOf(last));
+ }
+ }
+
+ /**
+ * 新加元素进行判断，如果前面是* / 直接运算，然后存入
+ * 如果+ - 暂时不运算
+ */
+ private static void addNum(Integer cur) {
+ String curNum = cur.toString();
+ String sign = queues.peekLast();
+ if ("*".equals(sign) || "/".equals(sign)) {
+ queues.removeLast();
+ String lastNum = queues.pollLast();
+ int result = calculateExpress(lastNum, curNum, sign);
+ queues.add(String.valueOf(result));
+ } else if ("+".equals(sign) || "-".equals(sign)) {
+ queues.add(curNum);
+ } else {
+ queues.add(curNum);
+ }
+ }
+
+ /**
+ * 如果+ - ,前两个有值运算前两个
+ * 否者直接加入
+ *
+ * @param sign
+ */
+ private static Integer addSign(char sign) {
+ if (sign == '+' || sign == '-' || sign == '(') {
+ String last = queues.peekLast();
+ if ("(".equals(last) || queues.size() < 2) {
+ } else if (queues.size() > 2) {
+ String prev1 = queues.removeLast();
+ String s = queues.removeLast();
+ String prev3 = queues.removeLast();
+ if ("(".equals(prev1)||"(".equals(s)||"(".equals(prev3)){
+ queues.add(prev3);
+ queues.add(s);
+ queues.add(prev1);
+ }else {
+ int result = calculateExpress(prev3, prev1, s);
+ queues.add(String.valueOf(result));
+ }
+ }
+ queues.add(String.valueOf(sign));
+ } else if (sign == '*' || sign == '/') {
+ queues.add(String.valueOf(sign));
+ }
+
+ if (sign == ')') {
+ String prev1 = queues.removeLast();
+ String s = queues.removeLast();
+ String prev3 = queues.removeLast();
+ int result = calculateExpress(prev3, prev1, s);
+ queues.removeLast();//移除左括号
+ queues.add(String.valueOf(result));
+ return result;
+ }
+ return 0;
+ }
+
+ /**
+ * 结果表示 遍历到哪一位，和计算结果
+ *
+ * @param formula
+ * @param
+ * @return
+ */
+ private static int[] calculate(String formula, int index) {
+
+ int s1 = 0;
+
+ char[] f = formula.toCharArray();
+ for (int i = index; i < formula.length(); i++) {
+ if (isNumber(f[i])) {
+ //转数字
+ s1 = s1 * 10 + f[i] - '0';
+
+ } else if (isSign(f[i])) {
+ // 运算符前一定有数字
+ if(s1>0) {
+ addNum(s1);
+ s1 = 0;
+ }
+ addSign(f[i]);
+ } else if (f[i] == '(') {
+ addSign(f[i]);
+ int result[] = calculate(formula, i + 1);
+ i = result[1];
+ //记录回溯的位置，因为后面还可能有元素要处理
+ //比如 1 + 2 *（ 3 + 4 ）+ 5
+ } else if (f[i] == ')') {
+ addNum(s1);
+ int result = addSign(f[i]);
+ s1 = 0;
+ return new int[]{result, i};
+ }
+
+ }
+ /**
+ * 综合计算
+ */
+ if (s1 != 0) {
+ addLastNum(s1);
+ s1 = 0;
+ }else{
+ if(queues.size()>1){
+ String last = queues.removeLast();
+ addLastNum(Integer.valueOf(last));
+ }
+ }
+
+ return new int[]{0, formula.length()};
+ }
+
+ private static boolean isSign(char c) {
+ if (c == '*' || c == '/' || c == '-' || c == '+') {
+ return true;
+ }
+ return false;
+ }
+
+ private static boolean isNumber(char c) {
+ return c >= '0' && c <= '9';
+ }
+
+ private static int calculateExpress(String s1, String s2, String sign) {
+ int num1 = Integer.parseInt(s1);
+ int num2 = Integer.parseInt(s2);
+ int result = 0;
+ switch (sign) {
+ case "*":
+ result = num1 * num2;
+ break;
+ case "/":
+ result = num1 / num2;
+ break;
+ case "+":
+ result = num1 + num2;
+ break;
+ case "-":
+ result = num1 - num2;
+ break;
+ }
+ return result;
+ }
+
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringGetMinCut.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringGetMinCut.java
new file mode 100644
index 0000000..31546c2
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringGetMinCut.java
@@ -0,0 +1,19 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringGetMinCut {
+
+ public static void main(String[]args){
+
+ String originStr = "ACDCDCDAD";
+
+
+ //A 0
+ //AC 1
+ // ACD 2
+ // ACDC 1
+ // ACDCD 2
+ // ACDCDC 2
+
+
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringISRotation.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringISRotation.java
new file mode 100644
index 0000000..59c448c
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringISRotation.java
@@ -0,0 +1,38 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringISRotation {
+
+ public static void main(String[] args) {
+
+ String a = "abcd1";
+ String b = "1abcd";
+
+ boolean result = isRotation(a, b);
+
+ System.out.println("结果：" + result);
+ }
+
+ private static boolean isRotation(String a, String b) {
+ if (a == null || b == null || a.length() != b.length()) {
+ return false;
+ }
+ String b2 = b + b;
+ return StringKMP.getIndexOf(b2,a)!=-1;
+ }
+
+ //KMP算法求是否包含子串 ，时间复杂度O(n+p)
+ private static int getIndexOf(String s, String m) {
+
+ if (s == null || m == null || m.length() < 1 || s.length() < m.length()) {
+ return -1;
+ }
+
+ char[] ss = s.toCharArray();
+ char[] ms = m.toCharArray();
+ int si = 0;
+ int mi = 0;
+// int []next = getNextArray(ms);
+ return 0;
+
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringKMP.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringKMP.java
new file mode 100644
index 0000000..a371502
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringKMP.java
@@ -0,0 +1,74 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringKMP {
+
+ public static void main(String[] args) {
+ String str1 = "ababacdcdefcdcag";
+ String str2 = "cdca";
+
+ System.out.println(getIndexOf(str1, str2));
+ }
+
+ static int getIndexOf(String source, String target) {
+ return kmp(source.toCharArray(), target.toCharArray());
+ }
+
+ static int kmp(char[] s, char[] p) {
+ int nextLength = Math.min(s.length, p.length);
+ int i = 0;
+ int j = 0;
+ int[] next = new int[nextLength];
+ getNextVal(p, next);
+ int sLen = s.length;
+ int pLen = p.length;
+ while (i < sLen && j < pLen) {
+ //①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++
+ if (j == -1 || s[i] == p[j]) {
+ i++;//等于-1 和匹配成功都++,为什么-1还++,表示前面还没有匹配成功
+ j++;
+ } else {
+ //②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]
+ //next[j]即为j所对应的next值
+ j = next[j];
+ }
+ }
+ if (j == pLen)
+ return i - j; //返回p在S中的位置
+ else
+ return -1;
+ }
+
+
+ /**
+ * 获取K值数组
+ *
+ * @param p
+ * @param next
+ *
+ */
+ static void getNextVal(char[] p, int next[]) {
+ int pLen = p.length;
+ next[0] = -1;
+ int k = -1;
+ int j = 0;
+ while (j < pLen-1) {
+ //p[k]表示前缀，p[j]表示后缀
+ if (k == -1 || p[j] == p[k]) {
+ j++;
+ k++;
+// next[j] = k;
+
+ if (p[j] != p[k])
+ next[j] = k; //之前只有这一行
+ else
+ //因为不能出现p[j] = p[ next[j ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
+ next[j] = next[k];
+
+ } else {
+ k = next[k];
+
+ }
+ }
+
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringMaxLengthNoRepeatSequence.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMaxLengthNoRepeatSequence.java
new file mode 100644
index 0000000..ccb5e76
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMaxLengthNoRepeatSequence.java
@@ -0,0 +1,45 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringMaxLengthNoRepeatSequence {
+
+ public static void main(String[] args) {
+ String str = "abcdaef";
+ String str2 = "abcdaefd";
+ System.out.println(getMaxLengthNoRepeatSequence(str2));
+
+ }
+
+ /**
+ * 分析
+ * abcda
+ * 当我们编译如果不之前没有出现过就算在内，如果出现过就保存当前不重复长度，
+ * 然后将启示位置跳转到重复元素第一次出现的地方，比如重复元素默认位置是-1
+ * 当array[4]位置又出现a ，判断曾经出现过，
+ * 我们保存元素可以使用一个256数组即可，数组里面对应位置保存的是对应位置
+ *
+ * @param s
+ * @return
+ */
+ public static int getMaxLengthNoRepeatSequence(String s) {
+ if (s == null || s.equals("")) {
+ return 0;
+ }
+ char[] chas = s.toCharArray();
+ int[] map = new int[256];
+ for (int i = 0; i < 256; i++) {
+ map[i] = -1;
+ }
+ int len = 0;//最长长度
+ int pre = -1;//保存前一个位置
+ int cur = 0;//保存当前位置到前一个重复位置的长度
+ for (int i = 0; i != chas.length; i++) {
+ //重复字符串的头部，如果map[chas[i]]有值，证明就是重复的
+ pre = Math.max(pre, map[chas[i]]);
+ cur = i - pre;
+ len = Math.max(len, cur);
+ map[chas[i]] = i;
+ }
+ return len;
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged.java
new file mode 100644
index 0000000..274a887
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged.java
@@ -0,0 +1,92 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * 两个集合映射组合算法
+ *
+ */
+public class StringMerged {
+
+ public static int N = 262144;//9组数据
+ private static String[] resultArray = new String[262144];
+ private static int itemSize = 4;//每次最大4个
+ public static int index = 0;
+ private static HashSet sets = new HashSet<>();
+
+ public HashSet findAllKindSplice(String str) {
+ sets.clear();//每次都清理掉集合
+ char[] chas = new char[itemSize];
+
+ char[] strArray = str.toCharArray();
+ for (int i = 0; i < chas.length; i++) {
+ chas[i] = ' ';
+ if (i < str.length()) {
+ chas[i] = strArray[i];
+ }
+ }
+
+ int length = itemSize;
+ for (int i = 0; i < resultArray.length; i++) {
+ char chasValue = ' ';
+ if (index == 0) {
+ if (i < N / length) {
+ chasValue = chas[0];
+ } else if (i < N / length * 2) {
+ chasValue = chas[1];
+ } else if (i < N / length * 3) {
+ chasValue = chas[2];
+ } else if (i < N) {
+ if (chas[3] != ' ') {
+ chasValue = chas[3];
+ } else {
+// chasValue = '*';
+ }
+ }
+ } else {
+ if (i % getCount(N, index - 1) < getCount(N, index)) {//0~3
+ chasValue = chas[0];
+ } else if (i % getCount(N, index - 1) < getCount(N, index) * 2) {
+ chasValue = chas[1];
+ } else if (i % getCount(N, index - 1) < getCount(N, index) * 3) {
+ chasValue = chas[2];
+ } else if (i % getCount(N, index - 1) < getCount(N, index) * 4) {
+ if (chas[3] != ' ') {
+ chasValue = chas[3];
+ }
+ }
+ }
+
+ if (resultArray[i] != null && chasValue != ' ') {
+ resultArray[i] = resultArray[i] + chasValue;
+ } else {
+ if (chasValue != ' ') {
+ resultArray[i] = "" + chasValue;
+ } else {
+ resultArray[i] = "";
+ }
+ }
+ //去掉多于元素，因为本次拼接长度一定比上次长
+ if (resultArray[i].length() > index) {
+ sets.add(resultArray[i]);
+ }
+ }
+
+ index++;
+// return resultArray;
+ return sets;
+ }
+
+ private static int getCount(int n, int index) {
+ if (index == 0) {
+ return n / itemSize;
+ } else {
+ return getCount(n / itemSize, --index);
+ }
+ }
+
+
+
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged2.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged2.java
new file mode 100644
index 0000000..de97105
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMerged2.java
@@ -0,0 +1,94 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 两个集合映射组合算法
+ */
+public class StringMerged2 {
+ public static Node root = new Node(null, "", null);
+
+ public static List currentNodeList = new ArrayList<>();
+
+ public static void main(String[] args) {
+ String str1 = "ABC";
+ String str2 = "DEF";
+ String str3 = "GHI";
+ String str4 = "JKL";
+ String str5 = "MNO";
+ String str6 = "PQRS";
+ String str7 = "TUVW";
+ String str8 = "XYZ";
+ findMerged(str1);
+ findMerged(str2);
+ findMerged(str3);
+ findMerged(str4);
+ findMerged(str5);
+ findMerged(str6);
+ findMerged(str7);
+
+ System.out.println("start=" + System.currentTimeMillis());
+ List results = findMerged(str8);
+ System.out.println("end=" + System.currentTimeMillis());
+// for (Leaf leaf : currentLeafList) {
+// System.out.print(leaf.value + ",");
+// }
+
+ System.out.println("总结果数量：" + results.size());
+// for (String result : results) {
+// System.out.print(result + ",");
+// }
+
+// List results = findMerged(str1);
+ }
+
+ public static List findMerged(String str) {
+ char chas[] = str.toCharArray();
+
+ if (currentNodeList.size() == 0) {
+ List list = new ArrayList<>();
+ for (char cha : chas) {
+ list.add(new Node(root, String.valueOf(cha), null));
+ }
+ currentNodeList = list;
+ } else {
+ List nodeList = new ArrayList<>();//底部叶子节点
+ for (Node node : currentNodeList) {
+ List childList = new ArrayList<>();//创建每一个孩子集合
+ for (char cha : chas) {
+ Node child = new Node(node, String.valueOf(cha), null);
+ childList.add(child);
+ nodeList.add(child);
+ }
+ node.childs = childList;
+ }
+ currentNodeList = nodeList;
+ }
+
+ List results = new ArrayList<>();
+ for (Node node : currentNodeList) {
+ String end = "";
+ Node current = node;
+ while (current != null) {
+ end = current.value + end;
+ current = current.parent;
+ }
+ results.add(end);
+ }
+ return results;
+ }
+
+
+ static class Node {
+ public Node parent;
+ public String value;
+ public List childs;
+
+ public Node(Node p, String value, List childs) {
+ this.parent = p;
+ this.childs = childs;
+ this.value = value;
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinIncludeStringLength.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinIncludeStringLength.java
new file mode 100644
index 0000000..496bd40
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinIncludeStringLength.java
@@ -0,0 +1,4 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringMinIncludeStringLength {
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinShortDistance.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinShortDistance.java
new file mode 100644
index 0000000..52838d7
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringMinShortDistance.java
@@ -0,0 +1,42 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringMinShortDistance {
+
+ public static void main(String args[]) {
+
+ String[] strings = new String[]{"1", "3", "3", "3", "2", "3", "1"};
+ System.out.println(minDistance(strings, "2", "1"));
+
+ }
+
+ public static int minDistance(String[] strs, String str1, String str2) {
+ if (str1 == null || str2 == null) {
+ return -1;
+ }
+ if (str1.equals(str2)) {
+ return 0;
+ }
+ int last1 = -1;
+ int last2 = -1;
+ int min = Integer.MAX_VALUE;
+ for (int i = 0; i != strs.length; i++) {
+ if (strs[i].equals(str1)) {
+ if (last2 != -1) {
+ min = Math.min(min, i - last2);
+ }
+ last1 = i;
+ }
+ if (strs[i].equals(str2)) {
+ if (last1 != -1) {
+ min = Math.min(min, i - last1);
+ }
+ last2 = i;
+ }
+ }
+
+ return min == Integer.MAX_VALUE ? -1 : min;
+ }
+
+ //如果实现时间复杂度O(1)，那么我们只能采用Hash表，因为两个参数，所以Value 还得用一个hash表
+ //最后我们把这个表先生成就好了
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringNewString.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringNewString.java
new file mode 100644
index 0000000..c9c1362
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringNewString.java
@@ -0,0 +1,4 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringNewString {
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringPerfectShuffleCard.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringPerfectShuffleCard.java
new file mode 100644
index 0000000..2c801ca
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringPerfectShuffleCard.java
@@ -0,0 +1,55 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+
+public class StringPerfectShuffleCard {
+ public static int N;
+ public static char chas[];
+
+ public static void main(String args[]) {
+ String str = "12345678";
+ chas = str.toCharArray();
+ N = str.length() / 2;
+ System.out.println(shuffleCard(str));
+ }
+
+ public static String shuffleCard(String str) {
+
+ for (int i = 1; i < N; ) {
+ int startIndex = i;
+ int curIndex = -1;
+ char currentValue = ' ';
+ while (curIndex != startIndex) {
+ if (curIndex == -1) {
+ curIndex = startIndex;
+ int nextIndex = getNextPosition(curIndex);
+ currentValue = chas[nextIndex];
+ chas[nextIndex] = chas[curIndex];
+ curIndex = nextIndex;
+ } else {
+ int nextIndex = getNextPosition(curIndex);
+ char nextValue = chas[nextIndex];
+ chas[nextIndex] = currentValue;
+ currentValue = nextValue;
+ curIndex = nextIndex;
+ }
+ }
+
+ i = i + 2;
+ }
+
+ return Arrays.toString(chas);
+ }
+
+ private static char getValue(int curIndex) {
+ return chas[curIndex];
+ }
+
+ public static int getNextPosition(int postion) {
+ if (postion < N) {
+ return 2 * postion;
+ } else {
+ return 2 * (postion - N) + 1;
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringReplace.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringReplace.java
new file mode 100644
index 0000000..d39cc15
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringReplace.java
@@ -0,0 +1,53 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringReplace {
+
+ public static void main(String[] args) {
+
+
+ }
+
+ public static void replace(char[] chas) {
+ if (chas == null || chas.length == 0) {
+ return;
+ }
+ int num = 0;
+ int len = 0;
+ for (len = 0; len < chas.length && chas[len] != 0; len++) {
+ if (chas[len] == ' ') {
+ num++;
+ }
+ }
+
+ int j = len + num * 2 - 1;
+ for (int i = len - 1; i > -1; i--) {
+ if (chas[i] != ' ') {
+ chas[j--] = chas[i];
+ } else {
+ chas[j--] = '0';
+ chas[j--] = '2';
+ chas[j--] = '%';
+ }
+ }
+ }
+
+ /**
+ * 有字符串的包含数组和* ,现在把星移动到所有数字前面
+ * @param chas
+ */
+ public void modify(char[]chas){
+
+ if(chas ==null ||chas.length==0){
+ return;
+ }
+ int j = chas.length-1;
+ for(int i= chas.length-1;i>-1;i--){
+ if(chas[i]!='*'){
+ chas[j--] = chas[i];
+ }
+ }
+ for(;j>-1;){
+ chas[j--] = '*';
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringReverse.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringReverse.java
new file mode 100644
index 0000000..31bb719
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringReverse.java
@@ -0,0 +1,89 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.Arrays;
+
+public class StringReverse {
+
+
+ public static void main(String[] args) {
+
+ String str = "I love you";
+
+ String result = getReverse2(str);
+ System.out.println(result);
+
+ }
+
+ //通过char 数组事项
+ private static String getReverse(String str) {
+ char[] chas = str.toCharArray();
+ int start = 0;
+ int end = chas.length - 1;
+ /**
+ * 实现思路 先全部反转，然后再局部反转
+ */
+ reverse(chas, start, end);
+
+ int l = -1;
+ int r = -1;
+ for (int i = 0; i < chas.length; i++) {
+ if (chas[i] != ' ') {
+ //找到l
+ if (i == 0 || chas[i - 1] == ' ') {
+ l = i;
+ }
+ //找到每一个r
+ if (i == chas.length - 1 || chas[i + 1] == ' ') {
+ r = i;
+ }
+ }
+ if (l != -1 && r != -1) {
+ reverse(chas, l, r);
+ l = -1;
+ r = -1;
+ }
+ }
+
+ return Arrays.toString(chas);
+ }
+
+ //通过String 数组也可以实现，但是会产生临时对象
+ private static String getReverse2(String str) {
+ String strArray[] = str.split(" ");
+
+ int start = 0;
+ int end = strArray.length - 1;
+ String tmp = "";
+ while (start < end) {
+ tmp = strArray[start];
+ strArray[start] = strArray[end];
+ strArray[end] = tmp;
+ start++;
+ end--;
+ }
+
+ String result = "";//StringBuilder
+ for (int i = 0; i < strArray.length; i++) {
+ if (i == strArray.length - 1) {
+ result = result+strArray[i];
+ } else {
+ result = result + strArray[i] + " ";
+ }
+
+ }
+ return result;
+ }
+
+
+ public static void reverse(char[] chas, int start, int end) {
+ char tmp = 0;
+ while (start < end) {
+ tmp = chas[start];
+ chas[start] = chas[end];
+ chas[end] = tmp;
+ start++;
+ end--;
+ }
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringRotateChange.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringRotateChange.java
new file mode 100644
index 0000000..843a897
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringRotateChange.java
@@ -0,0 +1,52 @@
+package com.wangpos.datastructure.algorithm;
+
+
+/**
+ * 旋转字符串
+ *
+ *
+ */
+public class StringRotateChange {
+
+ public static void main(String[] args) {
+
+ String s1 = "abcd";
+ String s2 = "dbac";//true
+
+ System.out.println("是否是旋转串=" + isRotateString(s1, s2));
+
+ String s3 = "abcd";
+ String s4 = "cadb";//false
+
+ System.out.println("是否是旋转串=" + isRotateString(s3, s4));
+ }
+
+ public static boolean isRotateString(String s1, String s2) {
+ if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0 || s1.length() != s2.length()) {
+ return false;
+ }
+ if (s1 == s2) {
+ return true;
+ }
+
+ char[] chas1 = s1.toCharArray();
+ char[] chas2 = s2.toCharArray();
+
+ /**
+ * 从上向下比较
+ */
+ int start = 0;
+ int end = chas2.length-1;
+ for (int i = chas1.length-1; i >0; i--) {
+ if (chas1[i] != chas2[end]) {
+ if (chas1[i] != chas2[start]) {
+ return false;
+ } else {
+ start++;
+ }
+ }
+ }
+
+ return true;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringSingleChar.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringSingleChar.java
new file mode 100644
index 0000000..142dbe9
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringSingleChar.java
@@ -0,0 +1,108 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringSingleChar {
+
+ public static void main(String[] args) {
+ String testStr1 = "aaabbb";
+ String testStr2 = "abcd";
+
+ System.out.println(isSingleCharString(testStr1));
+ System.out.println(isSingleCharString(testStr2));
+
+ System.out.println(isUnique2(testStr1.toCharArray()));
+ System.out.println(isUnique2(testStr2.toCharArray()));
+ }
+
+ // O (n)
+ public static boolean isSingleCharString(String str) {
+ char[] chars = str.toCharArray();
+ int[] counts = new int[256];
+ for (char aChar : chars) {
+ if (counts[aChar] > 0) {
+ return false;
+ }
+ counts[aChar]++;
+ }
+ return true;
+ }
+
+ // 要求空间复杂度O 1
+ /**
+ * 所有O(n)时间复杂度的排序算法（桶排序，基数排序，计数排序）都需要额外空间排序，所以空间复杂度不是O(1)
+ * 那么看O(nlogn)时间复杂度算法 （归并排序，快速排序，希尔排序，堆排序）
+ * 归并排序中有连个数组合并成一个数组过程，这个过程需要辅助数组来完成
+ * 快速排序额外空间复杂度最低 logN
+ * 希尔排序同样也排除，因为他的时间复杂度不固定，最低N*N,取决于步长
+ * 堆排序 可以时间复杂度能稳定O(NlogN) 并且空间复杂度是O(1),但是要使用非递归实现
+ * 否则会浪费函数栈空间
+ *
+ * @param chas
+ * @return
+ */
+ //堆排序 O(nlogn) 空间复杂度O(1)
+ public static boolean isUnique2(char[] chas) {
+
+ if (chas == null) {
+ return true;
+ }
+ heapSort(chas);
+ for (int i = 1; i < chas.length; i++) {
+ if (chas[i] == chas[i - 1]) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static void heapSort(char[] chas) {
+ for (int i = 0; i < chas.length; i++) {
+ heapInsert(chas, i);
+ }
+ for (int i = chas.length - 1; i > 0; i--) {
+ swap(chas, 0, i);
+ heapify(chas, 0, i);
+ }
+ }
+
+ public static void heapify(char[] chas, int i, int size) {
+ int left = i * 2 + 1;
+ int right = i * 2 + 2;
+ int largest = i;
+ while ((left < size)) {
+ if (chas[left] > chas[i]) {
+ largest = left;
+ }
+ if (right < size && chas[right] > chas[largest]) {
+ largest = right;
+ }
+ if (largest != i) {
+ swap(chas, largest, i);
+ } else {
+ break;
+ }
+ i = largest;
+ left = i * 2 + 1;
+ right = i * 2 + 2;
+ }
+ }
+
+ public static void heapInsert(char[] chas, int i) {
+ int parent = 0;
+ while (i != 0) {
+
+ parent = (i - 1) / 2;
+ if (chas[parent] < chas[i]) {
+ swap(chas, parent, i);
+ i = parent;
+ } else {
+ break;
+ }
+ }
+ }
+
+ public static void swap(char[] chas, int index1, int index2) {
+ char tmp = chas[index1];
+ chas[index1] = chas[index2];
+ chas[index2] = tmp;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringToDiKaEr.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToDiKaEr.java
new file mode 100644
index 0000000..8aa4262
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToDiKaEr.java
@@ -0,0 +1,103 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class StringToDiKaEr {
+
+
+ public static void main(String[] args) {
+ List> list = new ArrayList>();
+ List listSub1 = new ArrayList();
+ List listSub2 = new ArrayList();
+ List listSub3 = new ArrayList();
+ List listSub4 = new ArrayList();
+ List listSub5 = new ArrayList();
+ List listSub6 = new ArrayList();
+ List listSub7 = new ArrayList();
+ List listSub8 = new ArrayList();
+ listSub1.add("A");
+ listSub1.add("B");
+ listSub1.add("C");
+
+ listSub2.add("D");
+ listSub2.add("E");
+ listSub2.add("F");
+
+ listSub3.add("G");
+ listSub3.add("H");
+ listSub3.add("I");
+
+ listSub4.add("J");
+ listSub4.add("K");
+ listSub4.add("L");
+
+ listSub5.add("M");
+ listSub5.add("N");
+ listSub5.add("O");
+
+ listSub6.add("P");
+ listSub6.add("Q");
+ listSub6.add("R");
+
+ listSub7.add("S");
+ listSub7.add("T");
+ listSub7.add("U");
+
+ listSub8.add("V");
+ listSub8.add("W");
+ listSub8.add("X");
+
+
+ list.add(listSub1);
+ list.add(listSub2);
+ list.add(listSub3);
+ list.add(listSub4);
+ list.add(listSub5);
+ list.add(listSub6);
+ list.add(listSub7);
+ list.add(listSub8);
+
+ System.out.println("start:"+System.currentTimeMillis());
+ List> result = new ArrayList>();
+ descartes(list, result, 0, new ArrayList());
+ System.out.println("end:"+System.currentTimeMillis());
+ }
+ /**
+ * Created on 2014年4月27日
+ *
+ * Discription:笛卡尔乘积算法
+ * 把一个List{[1,2],[3,4],[a,b]}转化成List{[1,3,a],[1,3,b],[1,4
+ * ,a],[1,4,b],[2,3,a],[2,3,b],[2,4,a],[2,4,b]}数组输出
+ *
+ *
+ * @param layer
+ * 中间参数
+ * @param curList
+ * 中间参数
+ */
+ private static void descartes(List> dimvalue,
+ List> result, int layer, List curList) {
+ if (layer < dimvalue.size() - 1) {
+ if (dimvalue.get(layer).size() == 0) {
+ descartes(dimvalue, result, layer + 1, curList);
+ } else {
+ for (int i = 0; i < dimvalue.get(layer).size(); i++) {
+ List list = new ArrayList(curList);
+ list.add(dimvalue.get(layer).get(i));
+ descartes(dimvalue, result, layer + 1, list);
+ }
+ }
+ } else if (layer == dimvalue.size() - 1) {
+ if (dimvalue.get(layer).size() == 0) {
+ result.add(curList);
+ } else {
+ for (int i = 0; i < dimvalue.get(layer).size(); i++) {
+ List list = new ArrayList(curList);
+ list.add(dimvalue.get(layer).get(i));
+ result.add(list);
+ }
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringToInt.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToInt.java
new file mode 100644
index 0000000..baf9199
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToInt.java
@@ -0,0 +1,82 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringToInt {
+
+ public static void main(String[] args) {
+
+ String str = "-123";
+ String str2 = "a2342";
+ String str3 = "02342";
+ int result = convert(str);
+
+ System.out.println(result);
+ }
+
+ /**
+ * 检测是否是数字字符
+ *
+ * @param chas
+ * @return
+ */
+ public static boolean isValid(char[] chas) {
+ //判断第一位是0到9的之外的数，而不是负号
+ if (chas[0] != '-' && (chas[0] < '0' || chas[0] > '9')) {
+ return false;
+ }
+ //如果第一位为负号，后面的不可以是0 也不能没有值
+ if (chas[0] == '-' && (chas.length == 1 || chas[1] == '0')) {
+ return false;
+ }
+ //第一位是0 但是长度大于1 false
+ if (chas[0] == '0' && chas.length > 1) {
+ return false;
+ }
+
+ //第二位以后是0 到9的数
+ for (int i = 1; i < chas.length; i++) {
+ if (chas[i] < '0' || chas[i] > '9') {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static int convert(String str) {
+ if (str == null || str.equals("")) {
+ return 0;//不能转
+ }
+ char[] chas = str.toCharArray();
+ if (!isValid(chas)) {
+ return 0;//不符合要求
+ }
+
+ //判断正负数
+ boolean posi = chas[0] != '-';
+ int minq = Integer.MIN_VALUE / 10;
+ int minr = Integer.MAX_VALUE % 10;
+ int res = 0;
+ int cur = 0;
+ //-2147483648 2147483647
+ //
+ //左程云. 程序员代码面试指南IT名企算法与数据结构题目最优解（第2版） (Chinese Edition) (Kindle位置3654). Kindle 版本.
+ //
+ //左程云. 程序员代码面试指南IT名企算法与数据结构题目最优解（第2版） (Chinese Edition) (Kindle位置3654). Kindle 版本.
+ //以负数进行计算 比如
+ // 123 第一次 -1 res = 0*10 -1 =-1 小于12
+ // 第二次 res = -1*10 -2 = -12 小于12 如果大于直接溢出，不管下一位是什么
+ // 第三次 res = -12*10 -3 = -123 如果等于 就比较最后一个值
+ for (int i = posi ? 0 : 1; i < chas.length; i++) {
+ cur = '0' - chas[i];//当前字符所代表的负数形式
+ if ((res < minq) || (res == minq && cur < minr)) {
+ return 0;
+ }
+ res = res * 10 + cur;
+
+ }
+ //判断正数最大值
+ if (posi && res == Integer.MIN_VALUE) {
+ return 0;//不能转
+ }
+ return posi ? -res : res;
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStatisticsString.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStatisticsString.java
new file mode 100644
index 0000000..39638a9
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStatisticsString.java
@@ -0,0 +1,39 @@
+package com.wangpos.datastructure.algorithm;
+
+public class StringToStatisticsString {
+
+
+ public static void main(String[] args) {
+
+ String target = "aaabbbbbccc3333cccdee";
+
+ String result = getCountString(target);
+
+ System.out.println(result);
+
+ }
+
+ public static String getCountString(String str) {
+
+ char[] chs = str.toCharArray();
+ String res = String.valueOf(chs[0]);
+
+ int num = 1;
+
+ for (int i = 1; i < chs.length; i++) {
+ if (chs[i] != chs[i - 1]) {
+ res = contact(res,String.valueOf(num),String.valueOf(chs[i]));
+ num = 1;
+ }else{
+ num++;
+ }
+ }
+ return contact(res,String.valueOf(num),"");
+ }
+
+ //统计字符串用_分割开，可以区分里面含数字的情况
+ public static String contact(String s1,String s2,String s3){
+ return s1+"_"+s2+(s3.equals("")?s3:"_"+s3);
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStringMinDistance.java b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStringMinDistance.java
new file mode 100644
index 0000000..415e87f
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/StringToStringMinDistance.java
@@ -0,0 +1,118 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+
+public class StringToStringMinDistance {
+
+ public static void main(String[] args) {
+
+ String start = "adc";
+ String to = "cab";
+ List words = new ArrayList<>();
+ words.add("cab");
+ words.add("acc");
+ words.add("cbc");
+ words.add("ccc");
+ words.add("cac");
+ words.add("cbb");
+ words.add("aab");
+ words.add("abb");
+
+ List> list = findMinPaths(start, to, words);
+
+ for (List strings : list) {
+ for (String str:strings){
+ System.out.print(" "+str+" ");
+ }
+ System.out.println();
+ }
+ }
+
+ public static List> findMinPaths(String start, String to, List list) {
+ list.add(start);
+ HashMap> nexts = getNexts(list);
+ HashMap distances = getDistance(start, nexts);
+ LinkedList pathList = new LinkedList<>();
+ List> res = new ArrayList<>();
+ getShortestPaths(start, to, nexts, distances, pathList, res);
+ return res;
+ }
+
+ private static void getShortestPaths(String cur, String to, HashMap> nexts,
+ HashMap distances, LinkedList solution,
+ List> res) {
+ solution.add(cur);
+ if (to.equals(cur)) {
+ res.add(new LinkedList(solution));
+ } else {
+ for (String next : nexts.get(cur)) {
+ if (distances.get(next) == distances.get(cur) + 1) {
+ getShortestPaths(next, to, nexts, distances, solution, res);
+ }
+ }
+ }
+ solution.pollLast();
+ }
+
+
+ public static HashMap getDistance(String start, HashMap> nexts) {
+ HashMap distances = new HashMap<>();
+ distances.put(start, 0);
+ Queue queue = new LinkedList();
+ queue.add(start);
+ HashSet set = new HashSet<>();
+ set.add(start);
+ while (!queue.isEmpty()) {
+ String cur = queue.poll();
+ for (String str : nexts.get(cur)) {
+ if (!set.contains(str)) {
+ distances.put(str, distances.get(cur) + 1);
+ queue.add(str);
+ set.add(str);
+ }
+ }
+ }
+
+ return distances;
+ }
+
+ public static HashMap> getNexts(List words) {
+ Set dict = new HashSet<>(words);
+
+ HashMap> nexts = new HashMap<>();
+ for (int i = 0; i < words.size(); i++) {
+ nexts.put(words.get(i), new ArrayList());
+ }
+ for (int i = 0; i < words.size(); i++) {
+ nexts.put(words.get(i), getNext(words.get(i), dict));
+ }
+ return nexts;
+ }
+
+ private static ArrayList getNext(String word, Set dict) {
+ ArrayList res = new ArrayList<>();
+ char[] chs = word.toCharArray();
+ for (char cur = 'a'; cur <= 'z'; cur++) {
+ for (int i = 0; i < chs.length; i++) {
+ if (chs[i] != cur) {
+ char tmp = chs[i];
+
+ chs[i] = cur; //替换
+ if (dict.contains(String.valueOf(chs))) {
+ res.add(String.valueOf(chs));
+ }
+ chs[i] = tmp; //替换回来
+ }
+ }
+ }
+ return res;
+ }
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/algorithm/TestStringMerged.java b/app/src/main/java/com/wangpos/datastructure/algorithm/TestStringMerged.java
new file mode 100644
index 0000000..cadf3b7
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/algorithm/TestStringMerged.java
@@ -0,0 +1,54 @@
+package com.wangpos.datastructure.algorithm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class TestStringMerged {
+
+ public static void main(String[] args) {
+
+ String str1 = "ABCD";
+
+ String str2 = "EFGH";
+
+ String str3 = "IJK";
+
+ String str4 = "LMN";
+
+ String str5 = "OPQ";
+
+ String str6 = "RST";
+
+ String str7 = "UVW";
+
+ String str8 = "XYZ";
+
+ StringMerged sm = new StringMerged();
+
+ sm.findAllKindSplice(str1);
+ sm.findAllKindSplice(str2);
+ sm.findAllKindSplice(str3);
+ sm.findAllKindSplice(str4);
+ sm.findAllKindSplice(str5);
+ sm.findAllKindSplice(str6);
+ sm.findAllKindSplice(str7);
+ System.out.println("startTime " + System.currentTimeMillis());
+ HashSet resultSet = sm.findAllKindSplice(str8);
+ System.out.println("endTime " + System.currentTimeMillis());
+
+
+// for (String s : resultArray) {
+// System.out.print(s + " ");
+// }
+
+ System.out.println();
+// System.out.println("______________________");
+////
+ System.out.println("种类" + resultSet.size());
+// for (String s : resultSet) {
+// System.out.print(s + " ");
+// }
+
+
+ }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/base/ArrayTest.kt b/app/src/main/java/com/wangpos/datastructure/leetcode/ArrayTest.kt
similarity index 92%
rename from app/src/main/java/com/wangpos/datastructure/base/ArrayTest.kt
rename to app/src/main/java/com/wangpos/datastructure/leetcode/ArrayTest.kt
index dd1868c..20e4d74 100644
--- a/app/src/main/java/com/wangpos/datastructure/base/ArrayTest.kt
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/ArrayTest.kt
@@ -1,7 +1,4 @@
-package com.wangpos.datastructure.base
-
-import com.wangpos.datastructure.algorithm.swap
-import java.util.*
+package com.wangpos.datastructure.leetcode
/**
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1.kt b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1.kt
new file mode 100644
index 0000000..772d021
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1.kt
@@ -0,0 +1,39 @@
+package com.wangpos.datastructure.leetcode
+
+import java.util.*
+
+
+/**
+ * 两数之和
+ *
+ * 暴力方法时间复杂度是O(n2)
+ *
+ * 也可以通过hash表降低查找时间，使其变成O(n),使用hash表注意给定数组中不能出现重复元素
+ */
+
+fun main() {
+ val nums = arrayOf(1, 2, 3, 4, 5, 6)
+ val target = 9
+ val resultArray = twoSum(nums, target)
+ println("结果：${Arrays.toString(resultArray)}")
+}
+
+/**
+ * 这种方法找不到所有的元素，只能找到一个，当存在里面有重复元素或不止一种情况
+ */
+fun twoSum(nums: Array, target: Int): IntArray {
+ // 一个hashMap存一个value 和position
+ val map = mutableMapOf()
+ for (i in 0 until nums.size) {
+ val targetData = target - nums[i]
+ if (map.containsKey(targetData)) {
+ val resultArray = IntArray(2)
+ resultArray[0] = map[targetData]!!
+ resultArray[1] = i
+ return resultArray
+ }
+ map.put(nums[i], i)
+ }
+ throw IllegalArgumentException("No two sum solution")
+}
+
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1038.kt b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1038.kt
new file mode 100644
index 0000000..52c09ab
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1038.kt
@@ -0,0 +1,100 @@
+package com.wangpos.datastructure.leetcode
+
+import java.util.*
+
+/**
+ * 二叉查找树（英语：Binary Search Tree），也称为 二叉搜索树、有序二叉树（Ordered Binary Tree）或排序二叉树（Sorted Binary Tree），是指一棵空树或者具有下列性质的二叉树：
+
+若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
+若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
+任意节点的左、右子树也分别为二叉查找树；
+没有键值相等的节点。
+二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为 O(\log n)O(logn)。二叉查找树是基础性数据结构，用于构建更为抽象的数据结构，如集合、多重集、关联数组等。
+
+二叉查找树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉查找树的存储结构。中序遍历二叉查找树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉查找树变成一个有序序列，构造树的过程即为对无序序列进行查找的过程。每次插入的新的结点都是二叉查找树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索、插入、删除的复杂度等于树高，期望 O(\log n)O(logn)，最坏 O(n)O(n)（数列有序，树退化成线性表）。
+
+
+
+虽然二叉查找树的最坏效率是 O(n)O(n)，但它支持动态查询，且有很多改进版的二叉查找树可以使树高为 O(\log n)O(logn)，从而将最坏效率降至 O(\log n)O(logn)，如 AVL 树、红黑树等。
+
+ */
+fun main() {
+
+ //右左根的遍历方式
+ //记忆搜索
+
+ //不存在相等的元素
+ val arrayNode = arrayOf(4, 1, 6, 0, 2, 5, 7, null, null, null, 3, null, null, null, 8)
+// val arrayNode = arrayOf( 6, 5, 7, 8)
+ var head: TreeNode? = null
+ arrayNode.forEach {
+ if (it != null) {
+ if (head == null) {
+ head = TreeNode(it)
+ } else {
+ createBinearySearchTree(head!!, it!!)
+ }
+ }
+ }
+ //打出中序遍历结果判断访问是否正确
+ head?.let { printNode(it) }
+
+ println()
+ head?.let { modifyNode(it) }
+ println()
+
+
+ println()
+ head?.let { printNode(it) }
+
+}
+
+fun createBinearySearchTree(head: TreeNode, it: Int) {
+
+ var next: TreeNode? = null
+ if (it > head.`val`) {
+ next = head.right
+ if (next == null) {
+ head.right = TreeNode(it)
+ return
+ }
+ } else {
+ next = head.left
+ if (next == null) {
+ head.left = TreeNode(it)
+ return
+ }
+ }
+
+ createBinearySearchTree(next, it)
+
+}
+
+//中序遍历左跟右
+fun printNode(head: TreeNode) {
+ head.left?.let { printNode(it) }
+ print(" ${head.`val`} ")
+ head.right?.let { printNode(it) }
+}
+
+
+
+var cacheTotal = 0
+//右 根 左 把每个节点和队列之前的计算和添加到队列，
+fun modifyNode(root: TreeNode) {
+ root.right?.let { modifyNode(it) }
+ print(" ${root.`val`} ")
+ if (cacheTotal==0) {
+ cacheTotal = root.`val`
+
+ } else {
+ cacheTotal += root.`val`
+ root.`val` = cacheTotal
+ }
+ root.left?.let { modifyNode(it) }
+}
+
+class TreeNode(var `val`: Int) {
+ var left: TreeNode? = null
+ var right: TreeNode? = null
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1203.java b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1203.java
new file mode 100644
index 0000000..8954932
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1203.java
@@ -0,0 +1,246 @@
+package com.wangpos.datastructure.leetcode;
+
+import android.support.annotation.NonNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ *
+ * 项目之间的依赖关系，用拓扑排序解决。这比较明显。
+ *
+ * 难点在于怎么理解“ 同一小组的项目，排序后在列表中彼此相邻 ”。
+ *
+ *
+ * 这个题通过提示可以知道使用两层拓扑排序，但是坑还是挺多的。
+ * 1.需要给单独的项目创建一个组
+ * 2.需要通过项目ID找到关联的组，同时需要维护组本身的序列
+ * 一开始想图省事，用一个group[]表示，后来发现这样有耦合问题。改用List维护组本身，用数组维护项目到组的映射关系，初始化List为m个，如果遇到单独的项目，
+ * 则把当前List大小设置为组ID分配给这个项目。通过这个解决了项目ID和组ID耦合的问题。
+ *
+ */
+public class LeetCode1203 {
+
+ public static void main(String args[]) {
+ int[] group = new int[]{-1, -1, 1, 0, 0, 1, 0, -1};
+ int n = 8;
+ int m = 2;
+ List> beforeItems = new ArrayList<>();
+ //[[],[6],[5],[6],[3,6],[],[],[]]
+ beforeItems.add(createItem());
+ beforeItems.add(createItem());
+ beforeItems.get(beforeItems.size() - 1).add(6);
+ beforeItems.add(createItem());
+ beforeItems.get(beforeItems.size() - 1).add(5);
+ beforeItems.add(createItem());
+ beforeItems.get(beforeItems.size() - 1).add(6);
+ beforeItems.add(createItem());
+ beforeItems.get(beforeItems.size() - 1).add(3);
+ beforeItems.get(beforeItems.size() - 1).add(6);
+ beforeItems.add(createItem());
+ beforeItems.add(createItem());
+ beforeItems.add(createItem());
+
+ int[] result = new LeetCode1203().sortItems(8, 2, group, beforeItems);
+ System.out.println(Arrays.toString(result));
+
+ }
+
+ @NonNull
+ private static List createItem() {
+ return new ArrayList();
+ }
+
+
+ Listqueue = new LinkedList<>();
+
+
+ //项目
+ static class Item {
+ //项目id
+ int id;
+
+ //初始化入度
+ int inputCnt;
+ //下一个项目
+ List nextItems = new ArrayList<>();
+
+ Item(int id) {
+ this.id = id;
+ }
+ }
+
+ //组
+ static class Group {
+ //组id
+ int id;
+
+ //入度
+ int inputCnt;
+
+ List items = new ArrayList<>();
+ //下一个 组
+ List nextGroups = new ArrayList<>();
+
+ Group(int id) {
+ this.id = id;
+ }
+ }
+
+ /**
+ * 使用邻接表的形式
+ * @param n
+ * @param m
+ * @param group
+ * @param beforeItems
+ * @return
+ */
+ public int[] sortItems(int n, int m, int[] group, List> beforeItems) {
+ //项目数组
+ Item[] items = new Item[n];
+
+ //用来保存已经绑定过item的group数组
+ Group[] itemToGroup = new Group[n];
+
+ //组
+ List oriGroups = new ArrayList<>();
+
+ //初始化组种类
+ for (int j = 0; j < m; j++) {
+ oriGroups.add(new Group(j));
+ }
+
+ //初始化项目
+ for (int i = 0; i < n; i++) {
+ items[i] = new Item(i);
+ }
+
+ /**
+ * 遍历每个项目，所属组
+ */
+ for (int i = 0; i < group.length; i++) {
+ int groupId = group[i];
+ if (groupId == -1) {// 项目不属于任何组
+ //创建一个新组
+ Group temp = new Group(oriGroups.size());
+ //保存到组列表
+ oriGroups.add(temp);
+ //组绑定这个项目,因为项目是按顺序的所以i就是这个项目
+ temp.items.add(i);
+ itemToGroup[i] = temp;
+ } else {
+ //根据组id 绑定项目
+ oriGroups.get(groupId).items.add(i);
+ itemToGroup[i] = oriGroups.get(groupId);
+ }
+ }
+
+ for (int i = 0; i < beforeItems.size(); i++) {
+ List array = beforeItems.get(i);
+ //初始化入度
+ items[i].inputCnt = array.size();
+ for (Integer itemId : array) {
+ //每个项目的下一个项目
+ items[itemId].nextItems.add(i);
+ //获取绑定项目后的组
+ Group beforeGroup = itemToGroup[itemId];
+ //当前组
+ Group curGroup = itemToGroup[i];
+ if (beforeGroup != curGroup) {
+ //前一个组保存他的下一个组
+ beforeGroup.nextGroups.add(curGroup);
+ //当前组入度多1
+ curGroup.inputCnt++;
+ }
+ }
+ }
+
+ Queue groupQueue = new LinkedList<>();
+
+ //找到入度为0的组添加到待遍历的队列中
+ for (Group ele : oriGroups) {
+ if (ele.inputCnt == 0) {
+ groupQueue.offer(ele);
+ }
+ }
+
+ if (groupQueue.isEmpty()) {
+ return new int[0];
+ }
+
+ int[] result = new int[n];
+ int resultIndex = 0;
+ while (!groupQueue.isEmpty()) {
+ int size = groupQueue.size();
+ for (int i = 0; i < size; i++) {
+ Group curGroup = groupQueue.poll();
+ Queue itemQueue = new LinkedList<>();
+ if (curGroup.items.isEmpty()) {
+ continue;
+ }
+
+ //再进行item拓扑排序
+ for (int temp : curGroup.items) {
+ if (items[temp].inputCnt == 0) {
+ itemQueue.offer(temp);
+ }
+ }
+
+ if (itemQueue.isEmpty()) {
+ return new int[0];
+ }
+
+ //
+ while (!itemQueue.isEmpty()) {
+ int itemQueueSize = itemQueue.size();
+ for (int j = 0; j < itemQueueSize; j++) {
+ Integer itemId = itemQueue.poll();
+ //保存结果
+ result[resultIndex++] = itemId;
+ //遍历下一个
+ for (int nextItemId : items[itemId].nextItems) {
+ items[nextItemId].inputCnt--;
+ if (items[nextItemId].inputCnt == 0 && curGroup.items.contains(nextItemId)) {
+ itemQueue.offer(nextItemId);
+ }
+ }
+ }
+ }
+
+ //项目中存在环
+ for (int itemId : curGroup.items) {
+ if (items[itemId].inputCnt > 0) {
+ return new int[0];
+ }
+ }
+
+ //遍历下一个组
+ for (Group nextGroup : curGroup.nextGroups) {
+ nextGroup.inputCnt--;
+ if (nextGroup.inputCnt == 0) {
+ groupQueue.offer(nextGroup);
+ }
+ }
+ }
+ }
+ //组中存在环
+ for (Group ele : oriGroups) {
+ if (ele.inputCnt > 0) {
+ return new int[0];
+ }
+ }
+
+ for (int k = 0; k < items.length; k++) {
+ if (items[k].inputCnt > 0) {
+ return new int[0];
+ }
+ }
+
+ return result;
+ }
+
+
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.java b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.java
new file mode 100644
index 0000000..65e3b74
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.java
@@ -0,0 +1,101 @@
+package com.wangpos.datastructure.leetcode;
+
+import java.util.Stack;
+
+public class LeetCode1214 {
+
+ public boolean twoSumBSTs(TreeNode root1, TreeNode root2, int target) {
+
+ Stack stack1 = new Stack<>();
+ Stack stack2 = new Stack<>();
+ searchRoot11(root1, stack1);
+ searchRoot22(root2, stack2);
+ int t = 0;
+ int small = stack1.pop();
+ int large = stack2.pop();
+ while (!stack1.empty() || !stack2.empty()) {
+ t = small + large;
+ if (t == target) {
+ return true;
+ } else if (t > target) {
+ // 取较小的
+ if(!stack1.empty()) {
+ small = stack1.pop();
+ }else{
+ break;
+ }
+ } else {
+ // 取较大的
+ if(!stack2.empty()) {
+ large = stack2.pop();
+ }else{
+ break;
+ }
+ }
+ }
+ return false;
+ }
+
+ private void searchRoot11(TreeNode root1, Stack stack) {
+ if (root1 == null) {
+ return;
+ }
+ searchRoot11(root1.getLeft(), stack);
+ stack.add(root1.getVal());
+ searchRoot11(root1.getRight(), stack);
+ }
+
+ private void searchRoot22(TreeNode root1, Stack stack) {
+
+ if (root1 == null) {
+ return;
+ }
+ searchRoot22(root1.getRight(), stack);
+ stack.add(root1.getVal());
+ searchRoot22(root1.getLeft(), stack);
+ }
+//
+// fun twoSumBSTs2(root1: TreeNode?, root2: TreeNode?, target: Int): Boolean {
+//
+// val stack1 = Stack()//从小到大 top最大
+// val stack2 = Stack()//从大到小
+// searchRoot11(root1, stack1)
+// searchRoot22(root2, stack2)
+// var t = 0
+// var small = stack1.pop()
+// var large = stack2.pop()
+// while (stack1.isNotEmpty() && stack2.isNotEmpty()) {
+// t = small + large
+// println(small)
+// println(large)
+// if (t == target) {
+// return true
+// } else if (t > target) {
+// // 取较小的
+// small = stack1.pop()
+// } else {
+// // 取较大的
+// large = stack2.pop()
+// }
+// }
+// return false
+// }
+//
+// fun searchRoot11(root1: TreeNode?, stack: Stack) {
+// if (root1 == null) {
+// return
+// }
+// searchRoot11(root1.left, stack)
+// stack.add(root1.`val`)
+// searchRoot11(root1.right, stack)
+// }
+//
+// fun searchRoot22(root2: TreeNode?, stack: Stack) {
+// if (root2 == null) {
+// return
+// }
+// searchRoot22(root2.right, stack)
+// stack.add(root2.`val`)
+// searchRoot22(root2.left, stack)
+// }
+}
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.kt b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.kt
new file mode 100644
index 0000000..8cbc305
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1214.kt
@@ -0,0 +1,138 @@
+package com.wangpos.datastructure.leetcode
+
+import java.util.*
+
+fun main() {
+
+ val root1Array = arrayOf(0, -10, 10)
+
+ val root2Array = arrayOf(5, 1, 7, 0, 2)
+
+ val target = 18
+
+ var root1: TreeNode? = null
+ var root2: TreeNode? = null
+ root1Array.forEach {
+ if (it != null) {
+ if (root1 == null) {
+ root1 = TreeNode(it)
+ } else {
+ createBinearySearchTree(root1!!, it!!)
+ }
+ }
+ }
+
+ root2Array.forEach {
+ if (it != null) {
+ if (root2 == null) {
+ root2 = TreeNode(it)
+ } else {
+ createBinearySearchTree(root2!!, it!!)
+ }
+ }
+ }
+
+// root1?.let { printNode(it) }
+// println()
+// root2?.let { printNode(it) }
+
+// val result = twoSumBSTs(root1, root2, target)
+
+// val result = twoSumBSTs2(root1, root2, target)
+ val result = LeetCode1214().twoSumBSTs(root1,root2,target);
+ println("结果：${result}")
+}
+
+/**
+ * 这种双层嵌套效率比较低，中序遍历时间复杂度是O(n) 后面的查找属于也是中序遍历所以O(n*n)
+ *
+ */
+fun twoSumBSTs(root1: TreeNode?, root2: TreeNode?, target: Int): Boolean {
+ searchRoot1(root1, root2, target)
+ return searchResult
+}
+
+fun searchRoot1(root1: TreeNode?, root2: TreeNode?, target: Int) {
+
+ if (root1 == null || searchResult) {
+ return
+ }
+ searchRoot1(root1?.left, root2, target)
+ if (root1.`val` > target) {
+ return
+ }
+ searchRoot2(root2, target - root1.`val`)
+ searchRoot1(root1?.right, root2, target)
+}
+
+var searchResult = false
+fun searchRoot2(root2: TreeNode?, i: Int) {
+ if (root2 == null || searchResult) {
+ return
+ }
+ searchRoot2(root2.left, i)
+ if (root2.`val` == i) {
+ searchResult = true
+ return
+ }
+ if (root2.`val` > i) {
+ return
+ }
+ searchRoot2(root2.right, i)
+}
+
+/**
+ * 将两个树进行中序遍历，和逆向中序，时间复杂度 O(n)*2
+ * 然后放入两个栈中，得到两个一个从小到大，一个从大到小的
+ *
+ * 然后遍历两个栈，如果相加之和小于t,就从最小的栈去继续找，反之从大的栈中找
+ *
+ *
+ */
+fun twoSumBSTs2(root1: TreeNode?, root2: TreeNode?, target: Int): Boolean {
+
+ val stack1 = Stack()//从小到大 top最大
+ val stack2 = Stack()//从大到小
+ searchRoot11(root1, stack1)
+ searchRoot22(root2, stack2)
+ var t = 0
+ var small = stack1.pop()
+ var large = stack2.pop()
+ while (stack1.isNotEmpty() || stack2.isNotEmpty()) {
+ t = small + large
+ println(small)
+ println(large)
+ if (t == target) {
+ return true
+ } else if (t > target) {
+ // 取较小的
+ if(stack1.isNotEmpty()) {
+ small = stack1.pop()
+ }
+ } else {
+ // 取较大的
+ if(stack1.isNotEmpty()) {
+ large = stack2.pop()
+ }
+ }
+ }
+ return false
+}
+
+fun searchRoot11(root1: TreeNode?, stack: Stack) {
+ if (root1 == null) {
+ return
+ }
+ searchRoot11(root1.left, stack)
+ stack.add(root1.`val`)
+ searchRoot11(root1.right, stack)
+}
+
+fun searchRoot22(root2: TreeNode?, stack: Stack) {
+ if (root2 == null) {
+ return
+ }
+ searchRoot22(root2.right, stack)
+ stack.add(root2.`val`)
+ searchRoot22(root2.left, stack)
+}
\ No newline at end of file
diff --git a/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1272.java b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1272.java
new file mode 100644
index 0000000..cf64245
--- /dev/null
+++ b/app/src/main/java/com/wangpos/datastructure/leetcode/LeetCode1272.java
@@ -0,0 +1,139 @@
+package com.wangpos.datastructure.leetcode;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ * 给你一个 有序的 不相交区间列表 intervals 和一个要删除的区间 toBeRemoved， intervals 中的每一个区间 intervals[i] = [a, b] 都表示满足 a <= x < b 的所有实数 x 的集合。
+ *
+ * 我们将 intervals 中任意区间与 toBeRemoved 有交集的部分都删除。
+ *
+ * 返回删除所有交集区间后， intervals 剩余部分的 有序 列表。
+ *
+ *
+ * 示例 1：
+ *
+ * 输入：intervals = [[0,2],[3,4],[5,7]], toBeRemoved = [1,6]
+ * 输出：[[0,1],[6,7]]
+ * 示例 2：
+ *
+ * 输入：intervals = [[0,5]], toBeRemoved = [2,3]
+ * 输出：[[0,2],[3,5]]
+ *
+ */
+public class LeetCode1272 {
+
+ public static void main(String[] args) {
+ LeetCode1272 testObject = new LeetCode1272();
+// int[][] nums = new int[][]{new int[]{3, 4}, new int[]{0, 3}, new int[]{0, 2}, new int[]{5, 7}};
+// int[] toBeRemoved = new int[]{1, 6};
+
+// int[][] nums = new int[][]{new int[]{0, 5}};
+// int[] toBeRemoved = new int[]{2, 3};
+
+// int[][] nums = new int[][]{new int[]{-5, -4}, new int[]{-3, -2}, new int[]{1, 2}, new int[]{3, 5},new int[]{8,9}};
+// int[] toBeRemoved = new int[]{-1, 4};
+
+ int[][] nums = new int[][]{new int[]{0, 100}};
+ int[] toBeRemoved = new int[]{0, 50};
+ testObject.removeInterval(nums, toBeRemoved);
+ }
+
+ public List> removeInterval(int[][] intervals, int[] toBeRemoved) {
+
+ //排序分别比较两个条件，按顺序比较
+ sortArray(intervals, new int[]{0, 1});
+
+ /**
+ *
+ * 0 2 0 3 3 4 5 7
+ * 1 6
+ *
+ * 0 1 6 7
+ *
+ */
+
+
+ List> result = new ArrayList<>();
+ int[] lastSaveArray = null;
+ for (int[] interval : intervals) {
+ if (interval[0] <= toBeRemoved[0]) {
+ if (interval[1] > toBeRemoved[0]) {
+ //修改 入队列
+
+ int backupDataRight = interval[1];
+ if (interval[0] != toBeRemoved[0]) {
+ interval[1] = toBeRemoved[0];
+
+ if (lastSaveArray == null) {
+ lastSaveArray = saveResult(result, interval);
+ } else if (lastSaveArray[0] == interval[0] && lastSaveArray[1] == interval[1]) {
+ continue;
+ } else {
+ lastSaveArray = saveResult(result, interval);
+ }
+
+ }
+
+ if (backupDataRight >= toBeRemoved[1]) {
+ int newArray[] = new int[]{toBeRemoved[1], backupDataRight};
+ lastSaveArray = saveResult(result, newArray);
+ }
+
+ } else {
+ lastSaveArray = saveResult(result, interval);
+ }
+ } else {
+ // 8 9 -1 4
+ //
+ if (interval[1] <= toBeRemoved[1]) {
+ // 8 9 1 10
+ //重复空间
+// lastSaveArray = saveResult(result, interval);
+ } else {
+ if (interval[0] <= toBeRemoved[1]) {
+ interval[0] = toBeRemoved[1];
+ }
+ lastSaveArray = saveResult(result, interval);
+ }
+ }
+ }
+
+
+ return result;
+ }
+
+ private int[] saveResult(List> result, int[] interval) {
+ int[] lastSaveArray;
+ lastSaveArray = interval;
+ List cell = new ArrayList();
+ cell.add(interval[0]);
+ cell.add(interval[1]);
+ result.add(cell);
+ return lastSaveArray;
+ }
+
+ private void sortArray(int[][] intervals, final int[] order) {
+ Arrays.sort(intervals, new Comparator