diff --git "a/1.1\345\210\206\346\262\273.png" "b/1.1\345\210\206\346\262\273.png"
deleted file mode 100644
index 9e3b1b4e1d4262dcd10e1d1ded31a66a524dc57f..0000000000000000000000000000000000000000
Binary files "a/1.1\345\210\206\346\262\273.png" and /dev/null differ
diff --git "a/1.2\345\210\206\346\262\273.png" "b/1.2\345\210\206\346\262\273.png"
deleted file mode 100644
index 8c0da3115dd92654786a31f99d14d5334f252f29..0000000000000000000000000000000000000000
Binary files "a/1.2\345\210\206\346\262\273.png" and /dev/null differ
diff --git a/alg.md b/alg.md
index fb4f8d13f13a2b8aeb83e94867e0b86166b50c3b..dcbfdcafec59aa8f393583509fb5fff617275f61 100644
--- a/alg.md
+++ b/alg.md
@@ -112,44 +112,51 @@ def generate_matrix(m: int, n: int) -> List[List[int]]:
     return matrix
 ```
 
+<u>思路</u>：srand()产生随机种子，以此产生随机数。使用 `bin()` 函数可以得到一个整数的二进制字符串。
+
+###### 2.算法实现及测试
+
+```c++
+class Solution:
+   def hammingWeight(self, n):
+        res = 0
+        while n:
+            res += n & 1
+            n >>= 1
+        return res
+```
 
+*思路*：使用n&1得到二进制末尾是否为 1;把n右移 1 位，直至结束。
 
-## 二维矩阵检索算法的思路
+**分治算法**：将一个大问题分成多个规模较小的子问题，分而治之。
 
-- 该程序首先通过 `generate_matrix` 函数生成一个大小为 `m*n` 的二维数组，其中每行和每列都是递增的。生成过程中，对于每个位置 `(i, j)`，如果它是首行或首列，则随机生成一个整数，否则选取它的左边和上边的数以及一个随机数中的最大值作为该位置的元素值。
-- 接着，程序通过 `searchMatrix` 函数在生成的二维数组中查找目标整数 `target`，该函数采用双指针法，从右上角开始遍历，如果当前元素比目标整数大，则向左移动指针，否则向下移动指针。如果遍历完整个数组-仍未找到目标整数，则返回 False。
-- 最后，程序打印出生成的二维数组和目标整数，并输出查找结果。
+###### 3.性能分析
 
-## 代码
 
-```python
-def searchMatrix(matrix: List[List[int]], target: int) -> bool:
-    if not matrix:
-        return False
-    row, col = 0, len(matrix[0]) - 1
-    while row < len(matrix) and col >= 0:
-        if matrix[row][col] == target:
-            return True
-        elif matrix[row][col] > target:
-            col -= 1
-        else:
-            row += 1
-    return False
-m, n = random.randint(2, 10), random.randint(2, 10)
-matrix = generate_matrix(m, n)
-print("Generated matrix:")
-for row in matrix:
-    print(row)
-target = random.randint(0, 30)
-print(f"Searching for target {target} in matrix...")
-result = searchMatrix(matrix, target)
-print(f"Result: {result}")
-```
 
+**空间性能**：
+$$
+O(1)
+$$
+**时间性能**：
+$$
+O(k)
+$$
+
+k 为 n 的二进制长度
+
+###### 4.代码测试
+
+![屏幕截图 2023-04-11 222830](C:\Users\崔\Pictures\Screenshots\屏幕截图 2023-04-11 222830.png)
+
+###### 5.心得体会
+
+git使用愈发熟悉，在文件的创建和对文件的提交上掌握程度提高，不会的问题及时询问同学解决。
 ## 测试结果
 
-![](C:\Users\XUZIY\Desktop\1.1分治.png)
+###### 6.实验环境
 
+win11.
 ![](C:\Users\XUZIY\Desktop\1.2分治.png)
 	在构建最大二叉树的过程中，每个节点最多会被访问两次，因此时间复杂度为 $O(n)$。而在最坏情况下，数组中的每个数都会成为树的根节点，因此二叉树的深度为 $O(n)$，所以总的时间复杂度为 $O(n\log n)$。
 
@@ -246,8 +253,3 @@ print(preorderTraversal(root))
 
 ​	在构建最大二叉树的过程中，每个节点最多会被访问两次，因此时间复杂度为 $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 6b2092b67b5bf6c16241d9078ee00afed8e61401..3fffee2fb3def9a54d343b908e0e3aa688bb4589 100644
--- a/alg.py
+++ b/alg.py
@@ -5,6 +5,7 @@ class Solution:
             res += n & 1
             n >>= 1
         return res
+        return res
 
 def searchMatrix(matrix: List[List[int]], target: int) -> bool:
     if not matrix:
@@ -46,4 +47,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 5e9393b9b568599f9e7788d70911de38c8d053e1..e440e5c842586965a7fb77deda2eca68612b1f53 100644
--- a/gen.py
+++ b/gen.py
@@ -1,21 +1 @@
-import random
-from typing import List
-def generate_matrix(m: int, n: int) -> List[List[int]]:
-    matrix = []
-    for i in range(m):
-        row = []
-        for j in range(n):
-            if i == 0 and j == 0:
-                row.append(random.randint(0, 30))
-            elif i == 0:
-                row.append(max(row[-1], random.randint(0, 30)))
-            elif j == 0:
-                col = [matrix[x][0] for x in range(i)]
-                row.append(max(col[-1], random.randint(0, 30)))
-            else:
-                col = [matrix[x][j] for x in range(i)]
-                row.append(max(row[-1], col[-1], random.randint(0, 30)))
-        matrix.append(row)
-    return matrix
-
-    nums = [3,2,1,6,0,5]
+3
\ No newline at end of file
diff --git a/test.py b/test.py
index f98ce218b3c1f389c7468b122dd82c7d797530ac..a78f40ebbcc698002189730f381851cc5be3e8ad 100644
--- a/test.py
+++ b/test.py
@@ -1,30 +1 @@
-import gen
-import alg
-m, n = random.randint(2, 10), random.randint(2, 10)
-matrix = generate_matrix(m, n)
-print("Generated matrix:")
-for row in matrix:
-    print(row)
-target = random.randint(0, 30)
-print(f"Searching for target {target} in matrix...")
-result = searchMatrix(matrix, target)
-print(f"Result: {result}")
-
-import alg
-
-n = gen.nums
-root = alg.constructMaximumBinaryTree(n)
-# 前序遍历二叉树
-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))
+00000000000000000000000000001011
\ No newline at end of file