diff --git a/src/main/java/tree/DiameterOfBinaryTree.java b/src/main/java/tree/DiameterOfBinaryTree.java
new file mode 100644
index 0000000..564dc71
--- /dev/null
+++ b/src/main/java/tree/DiameterOfBinaryTree.java
@@ -0,0 +1,33 @@
+package tree;
+/**
+ * 题目： 543. 二叉树的直径  (diameterOfBinaryTree)
+ * 描述：给你一棵二叉树的根节点，返回该树的 直径 。
+ * 二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。
+ * 两节点之间路径的 长度 由它们之间边数表示。
+
+ * 链接：https://leetcode.cn/problems/diameter-of-binary-tree/
+
+ */
+public class DiameterOfBinaryTree {
+
+    private int maxDiameter = 0;
+    public int diameterOfBinaryTree(TreeNode root) {
+        depth(root);
+        return maxDiameter;
+    }
+
+    // 递归函数，返回以 node 为根的树的深度
+    private int depth(TreeNode node) {
+        if (node == null) {
+            return 0;
+        }
+        int leftDepth = depth(node.left);
+        int rightDepth = depth(node.right);
+
+        // 直径为左子树深度+右子树深度
+        maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth);
+
+        // 返回当前树的深度
+        return Math.max(leftDepth, rightDepth) + 1;
+    }
+}
diff --git a/src/main/java/tree/InvertTree.java b/src/main/java/tree/InvertTree.java
new file mode 100644
index 0000000..56e598f
--- /dev/null
+++ b/src/main/java/tree/InvertTree.java
@@ -0,0 +1,34 @@
+package tree;
+/**
+ * 题目： 226. 翻转二叉树  (invertTree)
+ * 描述：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
+
+ * 链接：https://leetcode.cn/problems/invert-binary-tree/
+
+ */
+public class InvertTree {
+    public void invert(TreeNode root){
+        if(root!=null){
+            TreeNode temp;
+            temp=root.left;
+            root.left=root.right;
+            root.right=temp;
+            invert(root.left);
+            invert(root.right);
+        }
+    }
+    public TreeNode invertTree1(TreeNode root) {
+        invert(root);
+        return root;
+    }
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+        TreeNode left = invertTree(root.left);
+        TreeNode right = invertTree(root.right);
+        root.left = right;
+        root.right = left;
+        return root;
+    }
+}
diff --git a/src/main/java/tree/IsSymmetric.java b/src/main/java/tree/IsSymmetric.java
new file mode 100644
index 0000000..e710793
--- /dev/null
+++ b/src/main/java/tree/IsSymmetric.java
@@ -0,0 +1,80 @@
+package tree;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 题目： 101. 对称二叉树  (invertTree)
+ * 描述：给你一个二叉树的根节点 root ， 检查它是否轴对称。
+
+ * 链接：https://leetcode.cn/problems/symmetric-tree/
+
+ */
+//不会做，递归和迭代都写一下
+public class IsSymmetric {
+
+    public boolean isSymmetric(TreeNode root) {
+        // 如果根节点为空，则认为是对称的
+        if (root == null) {
+            return true;
+        }
+        // 调用辅助函数，判断左子树与右子树是否互为镜像
+        return isMirror(root.left, root.right);
+    }
+
+    // 辅助函数：判断两个子树是否互为镜像
+    private boolean isMirror(TreeNode left, TreeNode right) {
+        // 如果两个节点都为空，则互为镜像
+        if (left == null && right == null) {
+            return true;
+        }
+        // 如果只有一个为空，则不对称
+        if (left == null || right == null) {
+            return false;
+        }
+        // 判断两个节点的值是否相等，并递归判断：
+        // 1. 左子树的左子树和右子树的右子树是否镜像
+        // 2. 左子树的右子树和右子树的左子树是否镜像
+        return (left.val == right.val)
+                && isMirror(left.left, right.right)
+                && isMirror(left.right, right.left);
+    }
+
+    public boolean isSymmetric1(TreeNode root) {
+        if (root == null) {
+            return true;
+        }
+
+        // 使用队列来存储成对的节点进行比较
+        Queue<TreeNode> queue = new LinkedList<>();
+        // 将根节点的左右子节点放入队列
+        queue.offer(root.left);
+        queue.offer(root.right);
+
+        while (!queue.isEmpty()) {
+            // 每次从队列中取出两个节点进行比较
+            TreeNode left = queue.poll();
+            TreeNode right = queue.poll();
+
+            // 如果两个节点均为空，说明这一对对称，继续下一对
+            if (left == null && right == null) {
+                continue;
+            }
+            // 如果只有一个为空，或者两个节点的值不相等，则不是对称树
+            if (left == null || right == null || left.val != right.val) {
+                return false;
+            }
+
+            // 将左右节点的子节点按照对称顺序加入队列：
+            // 1. 左子节点的左子树和右子节点的右子树
+            // 2. 左子节点的右子树和右子节点的左子树
+            queue.offer(left.left);
+            queue.offer(right.right);
+            queue.offer(left.right);
+            queue.offer(right.left);
+        }
+
+        // 遍历完所有节点对后，没有发现不对称的情况
+        return true;
+    }
+}
diff --git a/src/main/java/tree/IsValidBST.java b/src/main/java/tree/IsValidBST.java
new file mode 100644
index 0000000..7e99ad0
--- /dev/null
+++ b/src/main/java/tree/IsValidBST.java
@@ -0,0 +1,17 @@
+package tree;
+/**
+ * 题目： 98. 验证二叉搜索树  (isValidBST)
+ * 描述：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。
+ * 有效 二叉搜索树定义如下：
+ * 节点的左子树只包含 小于 当前节点的数。
+ * 节点的右子树只包含 大于 当前节点的数。
+ * 所有左子树和右子树自身必须也是二叉搜索树。
+
+ * 链接：https://leetcode.cn/problems/validate-binary-search-tree/
+
+ */
+public class IsValidBST {
+    public boolean isValidBST(TreeNode root) {
+        return false;
+    }
+}
diff --git a/src/main/java/tree/LevelOrder.java b/src/main/java/tree/LevelOrder.java
new file mode 100644
index 0000000..77a2feb
--- /dev/null
+++ b/src/main/java/tree/LevelOrder.java
@@ -0,0 +1,39 @@
+package tree;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * 题目： 102. 二叉树的层序遍历  (levelOrder)
+ * 描述：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
+
+ * 链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/
+
+ */
+public class LevelOrder {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>>res=new ArrayList<>();
+        if(root==null)
+            return new ArrayList<>();
+        Queue<TreeNode>queue=new LinkedList<>();
+        queue.offer(root);
+        while (!queue.isEmpty()){
+            int levelSize = queue.size();
+            List<Integer>list=new ArrayList<>();
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode tp=queue.poll();
+                list.add(tp.val);
+                if(tp.left!=null) {
+                    queue.offer(tp.left);
+                }
+                if(tp.right!=null) {
+                    queue.offer(tp.right);
+                }
+            }
+            res.add(list);
+        }
+        return res;
+    }
+}
diff --git a/src/main/java/tree/MaxDepth.java b/src/main/java/tree/MaxDepth.java
new file mode 100644
index 0000000..7f69a62
--- /dev/null
+++ b/src/main/java/tree/MaxDepth.java
@@ -0,0 +1,57 @@
+package tree;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 题目： 104. 二叉树的最大深度  (maxDepth)
+ * 描述：给定一个二叉树 root ，返回其最大深度。
+ * 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
+
+ * 链接：https://leetcode.cn/problems/maximum-depth-of-binary-tree/
+
+ */
+public class MaxDepth {
+    //递归
+    int dfs(TreeNode root){
+        if(root==null)
+            return 0;
+        return Integer.max(dfs(root.left),dfs(root.right))+1;
+    }
+    public int maxDepth1(TreeNode root) {
+        return dfs(root);
+    }
+    //bfs
+    public int maxDepth(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        int depth = 0;
+
+        // 每次while循环处理一层节点
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();  // 当前层节点数量
+            // 遍历当前层所有节点
+            for (int i = 0; i < levelSize; i++) {
+                TreeNode node = queue.poll();
+                // 如果存在左子节点，则加入队列
+                if (node.left != null) {
+                    queue.offer(node.left);
+                }
+                // 如果存在右子节点，则加入队列
+                if (node.right != null) {
+                    queue.offer(node.right);
+                }
+            }
+            // 每处理完一层，深度加1
+            depth++;
+        }
+
+        return depth;
+    }
+}
diff --git a/src/main/java/tree/MaxDepth.py b/src/main/java/tree/MaxDepth.py
deleted file mode 100644
index e69de29..0000000
diff --git a/src/main/java/tree/SortedArrayToBST.java b/src/main/java/tree/SortedArrayToBST.java
new file mode 100644
index 0000000..5821e40
--- /dev/null
+++ b/src/main/java/tree/SortedArrayToBST.java
@@ -0,0 +1,23 @@
+package tree;
+/**
+ * 题目： 108. 将有序数组转换为二叉搜索树  (sortedArrayToBST)
+ * 描述：给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。
+
+ * 链接：https://leetcode.cn/problems/convert-sorted-array-to-binary-search-tree/
+
+ */
+public class SortedArrayToBST {
+    //分治
+    TreeNode func(int left,int right ,int[] nums){
+        if(left>right)
+            return null;
+        int mid=(right+left)/2;
+        TreeNode root=new TreeNode(nums[mid]);
+        root.left=func(left,mid-1,nums);
+        root.right=func(mid+1,right,nums);
+        return root;
+    }
+    public TreeNode sortedArrayToBST(int[] nums) {
+        return func(0,nums.length-1,nums);
+    }
+}
diff --git a/src/test/java/tree/SortedArrayToBSTTest.java b/src/test/java/tree/SortedArrayToBSTTest.java
new file mode 100644
index 0000000..636abde
--- /dev/null
+++ b/src/test/java/tree/SortedArrayToBSTTest.java
@@ -0,0 +1,15 @@
+package tree;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class SortedArrayToBSTTest {
+
+    @Test
+    public void sortedArrayToBST() {
+        int[]nums = {-10,-3,0,5,9};
+        SortedArrayToBST solution = new SortedArrayToBST();
+        solution.sortedArrayToBST(nums);
+    }
+}
\ No newline at end of file