diff --git "a/1.1\345\210\206\346\262\273.png" "b/1.1\345\210\206\346\262\273.png"
new file mode 100644
index 0000000000000000000000000000000000000000..9e3b1b4e1d4262dcd10e1d1ded31a66a524dc57f
Binary files /dev/null and "b/1.1\345\210\206\346\262\273.png" differ
diff --git "a/1.2\345\210\206\346\262\273.png" "b/1.2\345\210\206\346\262\273.png"
new file mode 100644
index 0000000000000000000000000000000000000000..8c0da3115dd92654786a31f99d14d5334f252f29
Binary files /dev/null and "b/1.2\345\210\206\346\262\273.png" differ
diff --git a/alg.md b/alg.md
index b36cb30c6f8a26e60cec7009dc39392d7d23df41..b3fd71d7e05329b22166e84b0f5a82ab49511bce 100644
--- a/alg.md
+++ b/alg.md
@@ -97,94 +97,3 @@ print(f"Result: {result}")
 ​	对于一个长度为 `n` 的不重复的整数数组 `nums`，构建最大二叉树的空间复杂度为 $O(n)$。
 
 在构建最大二叉树的过程中，每个节点最多会被访问两次，因此递归栈的空间复杂度为 $O(n)$。此外，由于最大二叉树的节点数为 $n$，因此需要额外的 $O(n)$ 的空间来存储二叉树的节点。因此总的空间复杂度为 $O(n)$。	
-
-# 解题报告：构建最大二叉树
-
-## 题目描述
-
-​	给定一个不重复的整数数组 `nums`，构建一个最大二叉树，其中根节点的值为 `nums` 中的最大值，左子树是构建在最大值左边的子数组的最大二叉树，右子树是构建在最大值右边的子数组的最大二叉树。
-
-## 思路分析
-
-​	对于一个不重复的整数数组 `nums`，我们可以通过以下步骤构建一个最大二叉树：
-
-1. 找到数组中的最大值及其索引。
-2. 创建根节点，其值为最大值。
-3. 递归地在最大值左边的子数组前缀上构建左子树。
-4. 递归地在最大值右边的子数组后缀上构建右子树。
-5. 返回构建好的最大二叉树的根节点。
-
-## 代码实现
-
-​	下面是python代码实现，其中`TreeNode`类定义了二叉树节点的结构，`constructMaximumbinaryTree`函数接收一个整数数组 `nums`，返回该数组构建的最大二叉树的根节点。在函数内部，首先判断如果 `nums` 数组为空，则直接返回 `None`。否则，找到数组中的最大值及其索引，创建根节点，其值为最大值。然后，递归地在最大值左边的子数组前缀上构建左子树，递归地在最大值右边的子数组后缀上构建右子树。最后，返回构建好的最大二叉树的根节点。
-
-```python
-# Definition for a binary tree node.
-class TreeNode:
-    def __init__(self, val=0, left=None, right=None):
-        self.val = val
-        self.left = left
-        self.right = right
-        
-def constructMaximumBinaryTree(nums):
-    # 如果数组为空，则返回None
-    if not nums:
-        return None
-        
-    max_num = max(nums)
-
-    # 找到数组中的最大值及其索引
-    idx = nums.index(max_num)
-
-    # 创建根节点，其值为最大值
-    root = TreeNode(max_num)
-
-    # 递归地在最大值左边的子数组前缀上构建左子树
-    root.left = constructMaximumBinaryTree(nums[:idx])
-
-    # 递归地在最大值右边的子数组后缀上构建右子树
-    root.right = constructMaximumBinaryTree(nums[idx+1:])
-        
-    # 返回构建好的最大二叉树的根节点
-    return root
-
-```
-
-## 测试示例
-
-​	下面是一个测试代码的例子：
-
-```python
-import alg
-nums = [3, 2, 1, 6, 0, 5]
-# 构建最大二叉树
-root = alg.constructMaximumBinaryTree(nums)
-# 前序遍历二叉树
-def preorderTraversal(root):
-    res = []
-    def helper(root):
-        # 如果树为空，则返回None
-        if not root:
-            return None
-        res.append(root.val)
-        helper(root.left)
-        helper(root.right)
-    helper(root)
-    return res
-# 打印遍历结果
-print(preorderTraversal(root))
-```
-
-​	这个测试代码将一个整数数组传递给 `constructMaximumBinaryTree` 函数，得到该数组构建的最大二叉树的根节点。然后，使用 `preorderTraversal` 函数进行前序遍历，并打印遍历结果。运行该测试代码将输出 `[6,3,2,1,5,0]`，即最大二叉树的前序遍历结果。
-
-## 时间复杂度分析
-
-​	对于一个长度为 `n` 的不重复的整数数组 `nums`，构建最大二叉树的时间复杂度为 $O(n\log n)$。
-
-​	在构建最大二叉树的过程中，每个节点最多会被访问两次，因此时间复杂度为 $O(n)$。而在最坏情况下，数组中的每个数都会成为树的根节点，因此二叉树的深度为 $O(n)$，所以总的时间复杂度为 $O(n\log n)$。
-
-## 空间复杂度
-
-​	对于一个长度为 `n` 的不重复的整数数组 `nums`，构建最大二叉树的空间复杂度为 $O(n)$。
-
-在构建最大二叉树的过程中，每个节点最多会被访问两次，因此递归栈的空间复杂度为 $O(n)$。此外，由于最大二叉树的节点数为 $n$，因此需要额外的 $O(n)$ 的空间来存储二叉树的节点。因此总的空间复杂度为 $O(n)$。	
diff --git a/alg.py b/alg.py
index 0d4a750a445e56ad2325c144a59a0b1f055d99bd..d550d71db65e7344489c1f2ed2ff4067ad60868b 100644
--- a/alg.py
+++ b/alg.py
@@ -38,4 +38,4 @@ def constructMaximumBinaryTree(nums):
     root.right = constructMaximumBinaryTree(nums[idx+1:])
         
     # 返回构建好的最大二叉树的根节点
-    return root
\ No newline at end of file
+    return root
diff --git a/gen.py b/gen.py
index a36c7d144530eabaaa3c7c54d087af65a1bd6a62..5e9393b9b568599f9e7788d70911de38c8d053e1 100644
--- a/gen.py
+++ b/gen.py
@@ -18,4 +18,4 @@ def generate_matrix(m: int, n: int) -> List[List[int]]:
         matrix.append(row)
     return matrix
 
-    nums = [3,2,1,6,0,5]
\ No newline at end of file
+    nums = [3,2,1,6,0,5]
diff --git a/main.cpp b/main.cpp
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/test.py b/test.py
index 5b80512cf5f28adc4f657db2399d3ee1ddee8f8a..f98ce218b3c1f389c7468b122dd82c7d797530ac 100644
--- a/test.py
+++ b/test.py
@@ -27,4 +27,4 @@ def preorderTraversal(root):
     helper(root)
     return res
 # 输出遍历结果
-print(preorderTraversal(root))
\ No newline at end of file
+print(preorderTraversal(root))