@@ -8,18 +8,38 @@
 */
 public class Main {
 public static void main(String[] args) {
-int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-int target = 7;
-int left = 0, right = arr.length - 1;
-while(left < right) {
-int mid = (left + right) >>> 1;
-if(target > arr[mid]) {
-left = mid + 1;
-} else {
-right = mid;
+Scanner in = new Scanner(System.in);
+int m = in.nextInt();
+int n = in.nextInt();
+in.nextLine();
+int numStr = n / 3 * m;
+String[] strs = new String[numStr];
+char[][] chars = new char[numStr][5];
+char[][] map = new char[m][n];
+for (int i = 0; i < numStr; i++) {
+strs[i] = in.next();
+chars[i] = strs[i].toCharArray();
+}
+int k = 0;
+for (int i = 0, j = 0; i < m; i++,j++) {
+k = 0;
+map[j][k++] = chars[i][4];
+map[j][k++] = chars[i][0];
+map[j][k++] = chars[i][2];
+
+}
+for (int i = numStr - 1, j = 0; i >= m; i--, j++) {
+k = 3;
+map[j][k++] = chars[i][4];
+map[j][k++] = chars[i][0];
+map[j][k++] = chars[i][2];
+}
+
+for (int i = 0; i < m; i++) {
+for (int j = 0; j < n; j++) {
+System.out.print(map[i][j]);
 }
+System.out.println();
 }
-//return arr[left] == target ? left : -1;
-System.out.println(left);
 }
 }

@@ -9,17 +9,13 @@ public static void main(String[] args) {
 int m = in.nextInt();
 int n = in.nextInt();
 in.nextLine();
-//输入的字符串数量为：(n+2)/3*m;4*6的为：(4+2)/3*4=8
+//输入的字符串数量为：(n+2)/3*m; 4*6的为：(4+2)/3*4=8
 int numStr = (n + 2) / 3 * m;
-System.out.println(numStr);
 String[] strs = new String[numStr];
 char[][] chars = new char[numStr][5];
 char[][] map = new char[m][n];
 for (int i = 0; i < numStr; i++) {
 strs[i] = in.next();
-}
-
-for (int i = 0; i < numStr; i++) {
 chars[i] = strs[i].toCharArray();
 }
 

@@ -0,0 +1,62 @@
+package tencent_cloud;
+
+
+import java.util.*;
+
+public class Solution {
+
+private static TreeNode root;
+
+
+static class TreeNode {
+int val;
+TreeNode left;
+TreeNode right;
+
+public TreeNode(int val) {
+this.val = val;
+this.left = null;
+this.right = null;
+}
+
+public TreeNode(int val, TreeNode left, TreeNode right) {
+this.val = val;
+this.left = null;
+this.right = null;
+}
+}
+
+public static LinkedList<Integer> isBST(TreeNode root, LinkedList<Integer> list) {
+if (root == null) return list;
+isBST(root.left, list);
+list.add(root.val);
+isBST(root.right, list);
+return list;
+}
+
+public static void add(int value) {
+root = add(root, value);
+}
+
+private static TreeNode add(TreeNode root, int value) {
+if (root == null) {
+return new TreeNode(value, null, null);
+}
+int compare = (value - root.val);
+if (compare > 0) root.right = add(root.right, value);
+if (compare < 0) root.left = add(root.left, value);
+return root;
+}
+
+public static void main(String[] args) {
+Solution tree = new Solution();
+int[] arr = {9,4,10,2,5,8,7,6,1,3};
+for (int i = 0; i < arr.length; i++) {
+tree.add(arr[i]);
+}
+
+LinkedList<Integer> list = new LinkedList<>();
+
+System.out.println(isBST(root, list));
+}
+}

@@ -0,0 +1,109 @@
+package tencent_cloud;
+
+
+import java.util.*;
+
+public class Solution2 {
+
+private static TreeNode root;
+
+static class TreeNode {
+int val;
+TreeNode left;
+TreeNode right;
+
+public TreeNode() {
+this.val = val;
+this.left = null;
+this.right = null;
+}
+
+public TreeNode(int val) {
+this.val = val;
+this.left = null;
+this.right = null;
+}
+}
+
+public static boolean isValidBST(TreeNode root) {
+long pre = Long.MIN_VALUE;
+Stack<TreeNode> stack = new Stack<>();
+while (root != null) {
+stack.push(root);
+root = root.left;
+}
+while (!stack.empty()) {
+TreeNode temp = stack.pop();
+if (temp.val <= pre)
+return false;
+pre = temp.val;
+if (temp.right != null) {
+TreeNode r = temp.right;
+while (r != null) {
+stack.push(r);
+r = r.left;
+}
+}
+}
+return true;
+}
+
+public static void addTreeNode(TreeNode node, String[] nodes) {
+// if (root == null) root = new TreeNode(data);
+//
+// //采用随机方式创建二叉树
+// if (Math.random() > 0.5) {
+// if (node.left == null) {
+// node.left = new TreeNode(data);
+// } else {
+// addTreeNode(node.left, data);
+// }
+// } else {
+// if (node.right == null) {
+// node.right = new TreeNode(data);
+// } else {
+// addTreeNode(node.right, data);
+// }
+// }
+
+}
+
+public static void creat(int[] nodes) {
+List<TreeNode> datas = new ArrayList<>();
+// 将一个数组的值依次转换为Node节点
+for (int val : nodes) {
+datas.add(new TreeNode(val));
+}
+// 第一个数为根节点
+root = datas.get(0);
+// 建立二叉树
+for (int i = 0; i < nodes.length / 2; i++) {
+// 左孩子
+datas.get(i).left = datas.get(i * 2 + 1);
+// 右孩子
+if (i * 2 + 2 < datas.size()) {//避免偶数的时候 下标越界
+datas.get(i).right = datas.get(i * 2 + 2);
+}
+}
+}
+
+
+public static void levelOrder(TreeNode root) {
+if (root == null) return;
+
+Queue<TreeNode> queue = new LinkedList<>();
+queue.add(root);
+while (!queue.isEmpty()) {
+TreeNode node = queue.poll();
+System.out.print(node.val + " ");
+if (node.left != null) queue.add(node.left);
+if (node.right != null) queue.add(node.right);
+}
+}
+
+public static void main(String[] args) {
+int[] nodes = {1, 8, 9, 11, 10, 6, 7, 3};
+creat(nodes);
+levelOrder(root);
+}
+}

@@ -0,0 +1,10 @@
+package tencent_cloud;
+
+
+import java.util.*;
+
+public class Solution3 {
+public static void main(String[] args) {
+
+}
+}

@@ -0,0 +1,9 @@
+package tw;
+
+import java.util.*;
+
+public class Solution {
+public static void main(String[] args) {
+
+}
+}

@@ -40,7 +40,10 @@ public static void printList(Node head) {
 System.out.println();
 }
 
-// HashSet-O(n), 删除无序链表重复元素
+/**
+* 删除无序链表重复元素 (保留一个重复)
+* HashSet-O(n)
+*/
 public static void removeListI(Node head) {
 if (head == null) return;
 Node pre = head;
@@ -58,7 +61,12 @@ public static void removeListI(Node head) {
 }
 }
 
-//O(n^2), 删除无序链表重复元素
+/**
+* 删除无序链表重复元素 (保留一个重复)
+* O(n^2)
+*
+* @param head
+*/
 public static void removeListII(Node head) {
 if (head == null) return;
 Node pre = null;
@@ -80,7 +88,12 @@ public static void removeListII(Node head) {
 }
 
 
-//O(n^2), 删除有序链表重复元素
+/**
+* 删除有序链表重复元素 (保留一个重复)
+* O(n^2)
+*
+* @param head
+*/
 public static void removeSortList(Node head) {
 if (head == null) return;
 Node pre = head;
@@ -95,6 +108,32 @@ public static void removeSortList(Node head) {
 }
 }
 
+/**
+* 删除有序链表重复元素 (不保留重复元素)
+* 先用end和end.next元素比较，
+* - 如果相等，则left移动。之后循环判断left和right两个指针是否指向同一个元素。如果相等，则说明没有相同的元素。哨兵cur向后移动。反之，则说明存在相同的元素，哨兵则将当前next指针指向right.next,将重复元素都删除
+*
+* @param head
+*/
+public static Node removeNoRepeat(Node head) {
+if (head == null) return head;
+Node dummy = new Node(0);
+dummy.next = head;
+Node node = dummy;
+while (node != null && node.next != null) {
+Node nextNode = node.next.next;
+while (nextNode != null && nextNode.value == node.next.value) {
+nextNode = nextNode.next;
+}
+if (node.next.next == nextNode) {
+node = node.next;
+} else {
+node.next = nextNode;
+}
+}
+return dummy.next;
+}
+
 public static void main(String[] args) throws IOException {
 //BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
 //int n = Integer.parseInt(bufferedReader.readLine());