diff --git a/alg.md b/alg.md
index bd60e14380c02a8a015d901418177e8228c19dbd..1f636c5deadb9a40cb16130277f1c536bc30d341 100644
--- a/alg.md
+++ b/alg.md
@@ -146,6 +146,7 @@ python3.11
 vs2022
 
 git.
+git.
 
 
 # 算法设计分析
@@ -550,4 +551,4 @@ print(preorderTraversal(root))
 
 ​	对于一个长度为 `n` 的不重复的整数数组 `nums`，构建最大二叉树的时间复杂度为 $O(n\log n)$。
 
-​	在构建最大二叉树的过程中，每个节点最多会被访问两次，因此时间复杂度为 $O(n)$。而在最坏情况下，数组中的每个数都会成为树的根节点，因此二叉树的深度为 $O(n)$，所以总的时间复杂度为 $O(n\log n)$。
\ No newline at end of file
+​	在构建最大二叉树的过程中，每个节点最多会被访问两次，因此时间复杂度为 $O(n)$。而在最坏情况下，数组中的每个数都会成为树的根节点，因此二叉树的深度为 $O(n)$，所以总的时间复杂度为 $O(n\log n)$。
diff --git a/alg.py b/alg.py
index 63038cf008cdb27665b00d44a14a84d84d6ed8c0..8b137891791fe96927ad78e64b0aad7bded08bdc 100644
--- a/alg.py
+++ b/alg.py
@@ -1,85 +1 @@
-def merge(a,b):
-    l=[]
-    f=s=0
-    while f<len(a) and s<len(b):
-        if a[f]<b[s]:
-            l.append(a[f])
-            f+=1
-        else:
-            l.append(b[s])
-            s+=1
- 
-    #如果a遍历完 b还有余下值没有和a中元素比较则
-    if f==len(a):
-        for i in b[s:]:       #巧用for循环遍历b中余下元素
-            l.append(i)
- 
-    else:
-        for i in a[f:]:
-            l.append(i)
- 
-    return l                #归一新数组
-def sort_merge(lists):      #针对大数组分化为最小数量级
-    if len(lists)<=1:
-        return lists
-    middle=len(lists)//2
-    left=sort_merge(lists[:middle])
-    right=sort_merge(lists[middle:])
-    return merge(left,right)
- 
-if __name__ == '__main__':
-    a=arr
-    p=sort_merge(a)
-    print(p)
-    print(a[3])
 
-class Solution:
-   def hammingWeight(self, n):
-        res = 0
-        while n:
-            res += n & 1
-            n >>= 1
-        return res
-        return res
-
-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
-
-# 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
diff --git a/gen.py b/gen.py
index 5bce2c01f326721568926f03e014570c5c03c05a..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 100644
--- a/gen.py
+++ b/gen.py
@@ -1,30 +0,0 @@
-import random
-def random_int_list(start, stop, length):
-    start, stop = (int(start), int(stop)) if start <= stop else (int(stop), int(start))
-    length = int(abs(length)) if length else 0
-    return [random.randint(start, stop) for _ in range(length)]
-
-arr=random_int_list(1,100,10)
-print(arr)  
-
-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]
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..460a78d78d01e7d29e62ce4dd3a6d395b819f74e
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,90 @@
+#include<iostream>
+#include<ctime>
+using namespace std;
+
+
+void merge(int* a, int low, int mid, int hight)  //合并函数
+{
+	int* b = new int[hight - low + 1];  //用 new 申请一个辅助函数
+	int i = low, j = mid + 1, k = 0;    // k为 b 数组的小标
+	while (i <= mid && j <= hight)
+	{
+		if (a[i] <= a[j])
+		{
+			b[k++] = a[i++];  //按从小到大存放在 b 数组里面
+		}
+		else
+		{
+			b[k++] = a[j++];
+		}
+	}
+	while (i <= mid)  // j 序列结束，将剩余的 i 序列补充在 b 数组中 
+	{
+		b[k++] = a[i++];
+	}
+	while (j <= hight)// i 序列结束，将剩余的 j 序列补充在 b 数组中 
+	{
+		b[k++] = a[j++];
+	}
+	k = 0;  //从小标为 0 开始传送
+	for (int i = low; i <= hight; i++)  //将 b 数组的值传递给数组 a
+	{
+		a[i] = b[k++];
+	}
+	delete[]b;     // 辅助数组用完后，将其的空间进行释放（销毁）
+}
+
+
+
+void mergesort(int* a, int low, int hight) //归并排序
+{
+	if (low < hight)
+	{
+		int mid = (low + hight) / 2;
+		mergesort(a, low, mid);          //对 a[low,mid]进行排序
+		mergesort(a, mid + 1, hight);    //对 a[mid+1,hight]进行排序
+		merge(a, low, mid, hight);       //进行合并操作
+	}
+}
+
+
+
+
+int main()
+{
+	int num[5] = { 0 };
+	while (num[4] == 0)
+	{
+		srand((int)time(0));  // 产生随机种子  把0换成NULL也行
+		for (int i = 0; i < 5; i++)
+		{
+			int a = (rand() % 100) + 1;
+			num[i] = a;
+		}
+	}
+	cout << "生成随机数组：" << endl;
+	for (int i = 0; i < 5; i++)
+		cout << num[i] << ' ';
+	cout << endl;
+
+	mergesort(num, 0, 4);
+	cout << "归并排序后的结果：" << endl;
+	for (int i = 0; i < 5; i++)
+		cout << num[i] << ' ';
+	cout << endl;
+
+	int k;
+	cout << "输入k:";
+	cin >> k;
+	if (k > 4) {
+		cout << "超过数组大小！";
+		return 0;
+	}
+	cout << "第k大的数为：";
+	cout << num[k - 1];
+
+
+	return 0;
+
+
+}
\ No newline at end of file