From 0391839cf223521a66eee588786cdaf4c0386285 Mon Sep 17 00:00:00 2001
From: linyongji <lyj18391569527@163.com>
Date: Wed, 20 Jan 2021 18:14:59 +0800
Subject: [PATCH] =?UTF-8?q?=E4=B8=BB=E5=88=86=E6=94=AF=E4=B8=8B=E5=AE=8C?=
 =?UTF-8?q?=E5=96=84=E4=BA=86=E5=89=8D=E9=9D=A2=E5=81=9A=E7=9A=84=E9=A2=98?=
 =?UTF-8?q?=EF=BC=8C=E5=8C=85=E6=8B=AC=E6=B7=BB=E5=8A=A0=E6=B3=A8=E9=87=8A?=
 =?UTF-8?q?=E5=92=8C=E5=AF=B9=E6=9C=89=E9=97=AE=E9=A2=98=E7=9A=84=E9=A2=98?=
 =?UTF-8?q?=E8=BF=9B=E8=A1=8C=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Alogrithm/.vs/Alogrithm/v16/.suo              | Bin 92160 -> 98304 bytes
 Alogrithm/Alogrithm/config/15_WordPattern.ini |   0
 Alogrithm/Alogrithm/config/4_IsPalindrome.ini |   3 ++
 Alogrithm/Alogrithm/include/15_WordPattern.h  |   0
 Alogrithm/Alogrithm/include/3_bool IsUgly.h   |   1 +
 .../Alogrithm/src/10_BinaryTreePaths.cpp      |  31 +++++++++------
 Alogrithm/Alogrithm/src/11_CanWinNim.cpp      |   3 +-
 Alogrithm/Alogrithm/src/12_IsValid.cpp        |   4 +-
 Alogrithm/Alogrithm/src/13_MyAtoi.cpp         |   4 +-
 Alogrithm/Alogrithm/src/14_SingleNumber.cpp   |   2 +-
 Alogrithm/Alogrithm/src/15_WordPattern.cpp    |   0
 .../src/1_ContainsNearbyDuplicate.cpp         |   5 +--
 .../Alogrithm/src/2_ExcelSheetColumnTitle.cpp |  16 ++++----
 Alogrithm/Alogrithm/src/3_bool IsUgly.cpp     |   4 +-
 Alogrithm/Alogrithm/src/4_IsPalindrome.cpp    |  18 ++++-----
 Alogrithm/Alogrithm/src/5_MinDepth.cpp        |  37 +++++++++++-------
 .../Alogrithm/src/6_ContainsDuplicate.cpp     |  15 ++++---
 Alogrithm/Alogrithm/src/7_MaxDepth.cpp        |  15 +++----
 Alogrithm/Alogrithm/src/8_HammingWeight.cpp   |   9 +++--
 Alogrithm/Alogrithm/src/9_AddBinary.cpp       |   6 +--
 Alogrithm/Alogrithm/src/main.cpp              |   6 +--
 21 files changed, 101 insertions(+), 78 deletions(-)
 create mode 100644 Alogrithm/Alogrithm/config/15_WordPattern.ini
 create mode 100644 Alogrithm/Alogrithm/include/15_WordPattern.h
 create mode 100644 Alogrithm/Alogrithm/src/15_WordPattern.cpp

diff --git a/Alogrithm/.vs/Alogrithm/v16/.suo b/Alogrithm/.vs/Alogrithm/v16/.suo
index 6177be5bdbfe520bf73d9618ff78d148118677f8..acef311fc34a856a69534276bad575f389302188 100644
GIT binary patch
delta 9735
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
bodWGnTd-~J&0Wo6AyD6JYl$lqSPuOk6@K}M

delta 7969
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

diff --git a/Alogrithm/Alogrithm/config/15_WordPattern.ini b/Alogrithm/Alogrithm/config/15_WordPattern.ini
new file mode 100644
index 0000000..e69de29
diff --git a/Alogrithm/Alogrithm/config/4_IsPalindrome.ini b/Alogrithm/Alogrithm/config/4_IsPalindrome.ini
index 1730509..e1b8877 100644
--- a/Alogrithm/Alogrithm/config/4_IsPalindrome.ini
+++ b/Alogrithm/Alogrithm/config/4_IsPalindrome.ini
@@ -15,4 +15,7 @@ Na=20
 nExpect=0
 [Test6]
 Na=-214748368
+nExpect=0
+[Test7]
+Na=-123321
 nExpect=0
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/include/15_WordPattern.h b/Alogrithm/Alogrithm/include/15_WordPattern.h
new file mode 100644
index 0000000..e69de29
diff --git a/Alogrithm/Alogrithm/include/3_bool IsUgly.h b/Alogrithm/Alogrithm/include/3_bool IsUgly.h
index e051f80..b0585bf 100644
--- a/Alogrithm/Alogrithm/include/3_bool IsUgly.h	
+++ b/Alogrithm/Alogrithm/include/3_bool IsUgly.h	
@@ -1,2 +1,3 @@
 #pragma once
+#include <stdio.h>
 bool IsUgly(int num);
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/src/10_BinaryTreePaths.cpp b/Alogrithm/Alogrithm/src/10_BinaryTreePaths.cpp
index b6a5f01..2074469 100644
--- a/Alogrithm/Alogrithm/src/10_BinaryTreePaths.cpp
+++ b/Alogrithm/Alogrithm/src/10_BinaryTreePaths.cpp
@@ -1,6 +1,5 @@
 #include "../include/10_BinaryTreePaths.h"
 
-
 void CreatBitTreeNode3(char str[][50], int return_count, TreeNode3* cur, int curIndex)
 {
 	if (str == NULL || return_count <= 0 || cur == NULL || curIndex >= return_count || curIndex < 0) {
@@ -43,34 +42,40 @@ TreeNode3* CreatBitTree3(char str[][50], int return_count)
 	CreatBitTreeNode3(str, return_count, head, 0);
 	return head;
 }
+
 void get_path(char** array, struct TreeNode3* root, int* returnSize, int* buf, int local)
 {
-	if (NULL == root) {
+	if (NULL == root) {//如果根节点为NULL，直接返回
 		return;
 	}
-	if (!root->left && !root->right) {
+	if (NULL == root->left && NULL == root->right) {//如果左右子树都为空
+		//说明找到路了，把缓冲区的打印出来即可
 		char* str = (char*)malloc(1024);
-		int len = 0;
-		for (int i = 0; i < local; i++)
-		{
-			len += sprintf(str + len, "%d->", buf[i]);
-		}
-		sprintf(str + len, "%d", root->val);
-		array[(*returnSize)++] = str;
+		int len = 0;						//这里len作为偏移量
+		for (int i = 0; i < local; i++)		//把找到的一条路径拼接起来，
+		{									
+			len += sprintf(str + len, "%d->", buf[i]);//sprintf返回成功写入字符个数
+		}									
+		sprintf(str + len, "%d", root->val);//拼接叶节点的最后一个值
+		array[(*returnSize)++] = str;		//把拼接好的字符串地址放到要返回的array中
 	}
-	else {
+	else {//如果左右子树不为空
+		// 把当前的值写进buf，层级+1，继续递归找路
 		buf[local++] = root->val;
 		get_path(array, root->left, returnSize, buf, local);
 		get_path(array, root->right, returnSize, buf, local);
 	}
 }
+//题目：给定一个二叉树，返回所有从根节点到叶子节点的路径。
+//思路：递归遍历二叉树，利用sprintf函数对路径进行拼接，拼接的路径作为字符串存放在二维字符串数组中
 char** binaryTreePaths(struct TreeNode3* root, int* returnSize) {
 	char** ret = (char**)malloc(sizeof(char*) * 1024);//定义一个二级指针，作为返回值返回二维字符串数组
 	*returnSize = 0;//用来保存二维字符串数组的元素个数
-	int buf[1024] = { 0 };//用来接收缓冲
-	get_path(ret, root, returnSize, buf, 0);
+	int buf[1024] = { 0 };//用来接收缓冲，树中的val
+	get_path(ret, root, returnSize, buf, 0);//调用函数，对二叉树进行递归遍历
 	return ret;
 }
+//释放二叉树
 void free_tree3(TreeNode3* T)//后序释放
 {
 	if (!T) {
diff --git a/Alogrithm/Alogrithm/src/11_CanWinNim.cpp b/Alogrithm/Alogrithm/src/11_CanWinNim.cpp
index bf39f63..7ab9fe4 100644
--- a/Alogrithm/Alogrithm/src/11_CanWinNim.cpp
+++ b/Alogrithm/Alogrithm/src/11_CanWinNim.cpp
@@ -1,5 +1,6 @@
 #include "../include/11_CanWinNim.h"
-
+//题目： Nim 游戏
+//思路：只要不是4的倍数，都可以赢得游戏，换句话说就是对手拿完石子以后，还剩四颗石子，则必输
 bool CanWinNim(int n) {
 	if (n % 4 != 0) {
 		return true;
diff --git a/Alogrithm/Alogrithm/src/12_IsValid.cpp b/Alogrithm/Alogrithm/src/12_IsValid.cpp
index 8782f62..8ef6947 100644
--- a/Alogrithm/Alogrithm/src/12_IsValid.cpp
+++ b/Alogrithm/Alogrithm/src/12_IsValid.cpp
@@ -1,7 +1,9 @@
 #include "../include/12_IsValid.h"
 #pragma warning(disable:6385)
 #pragma warning(disable:6386)
-//思路：让左括号进栈，右括号和左括号依次进行匹配。
+//题目：括号匹配问题
+//思路：定义一个标志位，让左括号进栈，标志位移动，之后右括号和左括号依次进行匹配，
+//		匹配上了标志位移动，最后判断标志位是否回到原位。
 bool IsValid(char* s) {
 	int s_len = strlen(s);//定义一个int变量，存放字符串长度
 	char* stack = (char*)malloc(sizeof(char) * (s_len + 2));//定义一个char*指针用来模拟一个栈
diff --git a/Alogrithm/Alogrithm/src/13_MyAtoi.cpp b/Alogrithm/Alogrithm/src/13_MyAtoi.cpp
index f80f3b7..7481dc2 100644
--- a/Alogrithm/Alogrithm/src/13_MyAtoi.cpp
+++ b/Alogrithm/Alogrithm/src/13_MyAtoi.cpp
@@ -1,5 +1,7 @@
 #include "../include/13_MyAtoi.h"
-
+//题目：字符串转整数
+//思路：先对无用的开头空格字符、正负号、非空格和非数字开头进行判断，是则返回0
+//		再对字符串遍历，相加得到整数。
 int MyAtoi(char* s) {
 	int Index = 0;//用来遍历字符串s，作为下标使用
 	int flag = 1;//符号标志位，>0则读到正号，<0则读到负号
diff --git a/Alogrithm/Alogrithm/src/14_SingleNumber.cpp b/Alogrithm/Alogrithm/src/14_SingleNumber.cpp
index 4f58fbb..e668e9e 100644
--- a/Alogrithm/Alogrithm/src/14_SingleNumber.cpp
+++ b/Alogrithm/Alogrithm/src/14_SingleNumber.cpp
@@ -1,6 +1,6 @@
 #include "../include/14_SingleNumber.h"
 
-
+//题目：给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
 //思路：使用异或，异或的性质：
 //	1.0异或任何数＝任何数
 //	2.任何数异或自己＝把自己置0
diff --git a/Alogrithm/Alogrithm/src/15_WordPattern.cpp b/Alogrithm/Alogrithm/src/15_WordPattern.cpp
new file mode 100644
index 0000000..e69de29
diff --git a/Alogrithm/Alogrithm/src/1_ContainsNearbyDuplicate.cpp b/Alogrithm/Alogrithm/src/1_ContainsNearbyDuplicate.cpp
index d3c605b..18cbaea 100644
--- a/Alogrithm/Alogrithm/src/1_ContainsNearbyDuplicate.cpp
+++ b/Alogrithm/Alogrithm/src/1_ContainsNearbyDuplicate.cpp
@@ -30,13 +30,12 @@ bool ContainsNearbyDuplicate(int* nums, int numsSize, int k)
 	node* arr = NULL;		//定义一个node 指针
 	int i = 0;
 	int j = 0;
-	arr = (node*)malloc(sizeof(node) * 100000);//为arr指针分配足够空间，用来保存数组
+	arr = (node*)malloc(sizeof(node) * numsSize);//为arr指针分配足够空间，用来保存数组
 	if (NULL == arr)
 	{
 		printf("内存分配失败\n");
 	}
-	else
-	{
+	else{
 		for (i = 0; i < numsSize; i++)//遍历数组nums，把nums里的值和对应的下标保存在arr中
 		{
 			arr[i].value = nums[i];
diff --git a/Alogrithm/Alogrithm/src/2_ExcelSheetColumnTitle.cpp b/Alogrithm/Alogrithm/src/2_ExcelSheetColumnTitle.cpp
index e216b2e..11707e9 100644
--- a/Alogrithm/Alogrithm/src/2_ExcelSheetColumnTitle.cpp
+++ b/Alogrithm/Alogrithm/src/2_ExcelSheetColumnTitle.cpp
@@ -2,16 +2,16 @@
 
 //给定一个整数，返回它在 Excel 表中相对应的列名称，如果在Excel表中找不到该列，则返回""。
 char* ExcelSheetColumnTitle(int n)
-{
-	char* ret = (char*)malloc(sizeof(char) * 10);//开辟一片空间，存需要返回的字符串
-	int i = 9;//
-	while (n)
+{	//int类型大于0的数为0~2147483647，可以用7个A~Z的字母表示，int不会超过26的7次方
+	char* ret = (char*)malloc(sizeof(char) * 8);//所以这里申请8字节的空间，一个字节存放\0标志
+	int i = 7;//用来访问i字符串中的每个字符
+	ret[7] = '\0';//给结尾赋上\0标志位
+	while (n)//当n等于0时结束
 	{
-		n -= 1;//给n减一，因为n后面是从'A'开始的
-		ret[i - 1] = n % 26 + 'A';//从后往前赋值，从最后一个赋值到第一个
+		n -= 1;//给n减一，因为n后面是从字符'A'开始的相加的
+		ret[i-1] = n % 26 + 'A';//从后往前赋值，从最后一个赋值到第一个
 		n /= 26;
-		i--;//给下一个赋值
+		i--;//给下一个字符赋值
 	}
-	ret[9] = '\0';
 	return ret + i;//去掉前面的前导字符，如果前面没有字符则指针后移
 }
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/src/3_bool IsUgly.cpp b/Alogrithm/Alogrithm/src/3_bool IsUgly.cpp
index b18b055..4c8bd01 100644
--- a/Alogrithm/Alogrithm/src/3_bool IsUgly.cpp	
+++ b/Alogrithm/Alogrithm/src/3_bool IsUgly.cpp	
@@ -1,6 +1,8 @@
-#include <stdio.h>
+
 #include "../include/3_bool IsUgly.h "  
 //判断一个数是否为丑数（能被2 3 5整除的数），能返回true，不能返回false
+//思路：对入参循环判断%2、%3、%5是否为0，是则除相应的数，否则跳出循环，对num判断，
+//为1，则说明能被2、3、5除尽，是丑数，否则不是。
 bool IsUgly(int num)
 {	//入参判断，如果小于等于0直接返回false
 	if (num <= 0) {
diff --git a/Alogrithm/Alogrithm/src/4_IsPalindrome.cpp b/Alogrithm/Alogrithm/src/4_IsPalindrome.cpp
index bd06958..4581747 100644
--- a/Alogrithm/Alogrithm/src/4_IsPalindrome.cpp
+++ b/Alogrithm/Alogrithm/src/4_IsPalindrome.cpp
@@ -1,12 +1,14 @@
 #include "../include/4_IsPalindrome.h"
-
+//题目：判断一个数是否为回文数
 //思路：对传进来的数先知道是几位数，再循环%10，再/10,取到每位上的数字，再逆序*10相加，得到翻转后的数
 //最后再和原数作对比。
 
 bool IsPalindrome(int x)
 {
+	if (x < 0)//如果入参为负数，则不是回文数，返回false
+		return false;
 	int x_Count = 1;//定义一个count用来统计传进来的数是几位数
-	long long x_Coln1 = x;//把传进来的数拷贝一份，后面会用到
+	int x_Coln1 = x;//把传进来的数拷贝一份，因为后面对要对x做除法运算
 	long long x_Turn = 0;//用来保存翻转后的值，考虑int翻转后溢出问题
 	while ((x / 10) != 0) {//通过循环来获得入参是几位数
 		x_Count++;
@@ -14,15 +16,11 @@ bool IsPalindrome(int x)
 	}
 	x = x_Coln1;//保存原数，后面还要用到
 	for (int i = 0; i < x_Count; i++) {//把逆置后的数存放到x_Turn中（保存的是正数）
-		int temp = x % 10;
-		x_Turn = x_Turn * 10 + temp;
-		x = x / 10;
+		int temp = x % 10;//取整数的个位数字
+		x_Turn = x_Turn * 10 + temp;//取到的数字逆序相加
+		x = x / 10;//除10，继续取个位数字
 	}
-	if (x_Coln1 < 0) {//判断入参是否为负数，是的话加上负号，不是则不用变
-		x_Turn = 0 - x_Turn;
-	}
-	if (x_Turn == x_Coln1) {//判断翻转后的数和原数是否相等
+	if (x_Turn == x_Coln1) //判断翻转后的数和原数是否相等
 		return true;
-	}
 	return false;
 }
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/src/5_MinDepth.cpp b/Alogrithm/Alogrithm/src/5_MinDepth.cpp
index 704e717..358aed8 100644
--- a/Alogrithm/Alogrithm/src/5_MinDepth.cpp
+++ b/Alogrithm/Alogrithm/src/5_MinDepth.cpp
@@ -1,23 +1,27 @@
 #include "../include/5_MinDepth.h"
+//题目：求一个二叉树的最小深度
+//思路：递归遍历这棵树
 
+//创建一棵二叉树，入参为字符串数组。
 TreeNode* CreatBitTree(char str[][50], int return_count)
-{
+{	//如果传进来的字符串数组为空，则返回空
 	if (str == NULL || return_count <= 0) {
 		return NULL;
-	}
+	}//给给根节点开辟一片空间
 	TreeNode* head = (TreeNode*)malloc(sizeof(TreeNode));
-	if (NULL == head) {
+	if (NULL == head) {//如果内存申请失败，返回NULL
 		return NULL;
-	}
+	}//给根节点的数据域赋值，
 	head->val = _ttoi(str[0]);
-	CreatBitTreeNode1(str, return_count, head, 0);
-	return head;
+	CreatBitTreeNode1(str, return_count, head, 0);//通过调用函数，给根节点以外的子树赋值
+	return head;//返回根节点
 }
+//函数功能是给根节点以外的子树赋值，入参为字符串数组、根节点、标志位
 void CreatBitTreeNode1(char str[][50], int return_count, TreeNode* cur, int curIndex)
-{
+{	//赋值前判空
 	if (str == NULL || return_count <= 0 || cur == NULL || curIndex >= return_count || curIndex < 0) {
 		return;
-	}
+	}//递归赋值
 	int last = return_count - 1;
 	if ((2 * curIndex + 1 <= last) && strcmp(str[2 * curIndex + 1], "NULL")) {
 		cur->left = (TreeNode*)malloc(sizeof(TreeNode));
@@ -42,29 +46,32 @@ void CreatBitTreeNode1(char str[][50], int return_count, TreeNode* cur, int curI
 	CreatBitTreeNode1(str, return_count, cur->left, 2 * curIndex + 1);
 	CreatBitTreeNode1(str, return_count, cur->right, 2 * curIndex + 2);
 }
+//找二叉树的最小深度
 int MinDepth(struct TreeNode* root)
 {
 	int Depth = 0;
 	int L1, L2;
-	if (NULL == root) {
+	if (NULL == root) {//如果根节点为空，返回0
 		return 0;
-	}
+	}//如果左右子树为空，返回1
 	else if ((NULL == root->left) && (NULL == root->right)) {
 		return 1;
-	}
+	}//如果左子树不为空，右子树为空，继续搜索左子树
 	else if ((NULL != root->left) && (NULL == root->right)) {
 		Depth = MinDepth(root->left);
-	}
+	}//如果左子树为空，右子树不为空，继续搜索右子树
 	else if ((NULL == root->left) && (NULL != root->right)) {
 		Depth = MinDepth(root->right);
-	}
+	}//如果都不为空，则两边搜索
 	else {
 		L1 = MinDepth(root->left);
 		L2 = MinDepth(root->right);
-		Depth = fmin(L1, L2);
+		Depth = fmin(L1, L2);//把左右子树中，深度较小的一个给Depth
 	}
-	return Depth + 1;
+	return Depth + 1;//每次搜索完，把搜索到的结果进行累加
 }
+
+//释放二叉树
 void free_tree(TreeNode* T)//后序释放
 {
 	if (!T) {
diff --git a/Alogrithm/Alogrithm/src/6_ContainsDuplicate.cpp b/Alogrithm/Alogrithm/src/6_ContainsDuplicate.cpp
index e3cf1be..5bb99f5 100644
--- a/Alogrithm/Alogrithm/src/6_ContainsDuplicate.cpp
+++ b/Alogrithm/Alogrithm/src/6_ContainsDuplicate.cpp
@@ -1,16 +1,19 @@
 #include"../include/6_ContainsDuplicate.h"
-
+//题目：给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回true 。
+//		如果数组中每个元素都不相同，则返回false 。
+//思路：先排序，然后比较相邻元素是否相等，若相等则返回true，否则返回false。
+//qsort比较函数，返回值小于0，升序；返回值大于0，降序
 int cmp_6(const void* _a, const void* _b) {
 	int a = *(int*)_a, b = *(int*)_b;
 	return a - b;
 }
-//6.排序，比较相邻元素是否相等，若相等则返回true，否则返回false。
+
 bool containsDuplicate(int* nums, int numsSize) {
-	qsort(nums, numsSize, sizeof(int), cmp_6);
-	for (int i = 0; i < numsSize - 1; i++) {
-		if (nums[i] == nums[i + 1]) {
+	qsort(nums, numsSize, sizeof(int), cmp_6);//对传进来的数组排序
+	for (int i = 0; i < numsSize - 1; i++) {//遍历数组，
+		if (nums[i] == nums[i + 1]) {//对相邻的两个元素作比较，如果相等返回true；
 			return true;
 		}
 	}
-	return false;
+	return false;//不相等，返回false
 }
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/src/7_MaxDepth.cpp b/Alogrithm/Alogrithm/src/7_MaxDepth.cpp
index 52af908..3b1b9b1 100644
--- a/Alogrithm/Alogrithm/src/7_MaxDepth.cpp
+++ b/Alogrithm/Alogrithm/src/7_MaxDepth.cpp
@@ -42,28 +42,29 @@ void CreatBitTreeNode2(char str[][50], int return_count, TreeNode2* cur, int cur
 	CreatBitTreeNode2(str, return_count, cur->left, 2 * curIndex + 1);
 	CreatBitTreeNode2(str, return_count, cur->right, 2 * curIndex + 2);
 }
+//返回二叉树中，最大深度
 int MaxDepth(struct TreeNode2* root)
 {
 	int Depth = 0;
 	int L1, L2;
-	if (NULL == root) {
+	if (NULL == root) {//根节点为NULL，返回0
 		return 0;
-	}
+	}//左右子树都为NULL，返回1
 	else if ((NULL == root->left) && (NULL == root->right)) {
 		return 1;
-	}
+	}//左子树不为NULL，右子树为NULL，继续搜索左子树
 	else if ((NULL != root->left) && (NULL == root->right)) {
 		Depth = MaxDepth(root->left);
-	}
+	}//右子树不为NUULL，左子树为NULL，继续搜索右子树
 	else if ((NULL == root->left) && (NULL != root->right)) {
 		Depth = MaxDepth(root->right);
-	}
+	}//如果左右子树都不为NULL，左右子树继续搜索
 	else {
 		L1 = MaxDepth(root->left);
 		L2 = MaxDepth(root->right);
-		Depth = fmax(L1, L2);
+		Depth = fmax(L1, L2);//返回左右子树中，较大的一个
 	}
-	return Depth + 1;
+	return Depth + 1;//每次搜索完，对Depth进行累加，最后返回。
 }
 void free_tree2(TreeNode2* T)//后序释放
 {
diff --git a/Alogrithm/Alogrithm/src/8_HammingWeight.cpp b/Alogrithm/Alogrithm/src/8_HammingWeight.cpp
index 23febbb..38d10f2 100644
--- a/Alogrithm/Alogrithm/src/8_HammingWeight.cpp
+++ b/Alogrithm/Alogrithm/src/8_HammingWeight.cpp
@@ -1,12 +1,13 @@
 #include"../include/8_HammingWeight.h"
-//8.定义一个count，记录1的个数，把入参和1与操作，如果为1，count加1；如果为0，count加0
-//把入参右移一位，循环上面的操作，直到n=0时结束。
+//题目：编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为‘1’的个数（也被称为汉明重量）。
+//思路：定义一个count，记录1的个数，把入参和1与操作，如果为1，count加1；如果为0，count加0
+
 int HammingWeight(uint32_t n)
 {
 	int n_Count = 0;
 	while (n) {
-		n_Count += n & 1;
-		n >>= 1;
+		n_Count += n & 1;//n & 1的结果为1或者0,1说明最后一位为1,0说明最后一位为0
+		n >>= 1;//把入参右移一位，循环上面的操作，直到n=0时结束。
 	}
 	return n_Count;
 }
\ No newline at end of file
diff --git a/Alogrithm/Alogrithm/src/9_AddBinary.cpp b/Alogrithm/Alogrithm/src/9_AddBinary.cpp
index fedc668..82411c9 100644
--- a/Alogrithm/Alogrithm/src/9_AddBinary.cpp
+++ b/Alogrithm/Alogrithm/src/9_AddBinary.cpp
@@ -1,12 +1,12 @@
 #include"../include/9_AddBinary.h"
-
+//题目：给你两个二进制字符串，返回它们的和（用二进制表示）。
+//思路：获得两个字符串长度，定义一个进位标志位，从字符串的后面往前加
 char* AddBinary(char* a, char* b)
 {
 	int len_a = strlen(a) - 1;//存放字符串a的长度
 	int len_b = strlen(b) - 1;//存放字符串b的长度
 	int carry = 0;//进位标志
 	int len = len_a > len_b ? len_a : len_b;//获取两个字符串中长度较长的哪一个
-
 	char* pstr = (char*)malloc(sizeof(char) * (len + 3));//定义一个指针作为返回值，多分配两个空间是为了防止有进位和字符结尾标志\0
 	if (NULL == pstr)
 		return NULL;
@@ -22,7 +22,7 @@ char* AddBinary(char* a, char* b)
 	}
 	//判断要不要加前导0
 	if (carry == 0) {
-		return (pstr + 1);//指针加一，表示指针向后移动，在这里如果不进位的话指针就指向非0的下一位。
+		return (pstr + 1);//指针加一，表示指针向后移动，
 	}
 	else {
 		pstr[0] = '1';
diff --git a/Alogrithm/Alogrithm/src/main.cpp b/Alogrithm/Alogrithm/src/main.cpp
index 6c0e666..b1b8c8a 100644
--- a/Alogrithm/Alogrithm/src/main.cpp
+++ b/Alogrithm/Alogrithm/src/main.cpp
@@ -1,9 +1,7 @@
 #include<stdio.h>
-#include "../include/13_MyAtoi.h"
-#include "../include/14_SingleNumber.h"
+#include "../include/4_IsPalindrome.h"
 int main()
 {
-	int arr[] = { -1,-2,-3,-4,-4,-3,-2,-1,0 };
-	printf("%d\n", SingleNumber(arr, sizeof(arr)/sizeof(int)));
+	printf("%d\n",IsPalindrome(-123321));
 	return 0;
 }