diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index f0a46a40..741a735a 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -315,5 +315,75 @@ class Solution {
 }
 ```
 
+C:
+```C
+typedef struct HashNodeTag {
+    int key;   /* num  */
+    struct HashNodeTag *next;
+}HashNode;
+
+/* Calcualte the hash key */
+static inline int hash(int key, int size) {
+    int index = key % size;
+    return (index > 0) ? (index) : (-index);
+}
+
+/* Calculate the sum of the squares of its digits*/
+static inline int calcSquareSum(int num) {
+    unsigned int sum = 0;
+    while(num > 0) {
+        sum += (num % 10) * (num % 10);
+        num = num/10; 
+    }
+    return sum;
+}
+
+#define HASH_TABLE_SIZE     (32)
+
+bool isHappy(int n){
+    int sum = n;
+    int index = 0;
+    bool bHappy = false;
+    bool bExit = false;
+    /* allocate the memory for hash table with chaining method*/
+    HashNode ** hashTable = (HashNode **)calloc(HASH_TABLE_SIZE, sizeof(HashNode));
+    
+    while(bExit == false) {
+        /* check if n has been calculated */
+        index = hash(n, HASH_TABLE_SIZE);
+
+        HashNode ** p = hashTable + index;
+
+        while((*p) && (bExit == false)) {
+            /* Check if this num was calculated, if yes, this will be endless loop */
+            if((*p)->key == n) { 
+                bHappy = false;
+                bExit = true;
+            }
+            /* move to next node of the same index */
+            p = &((*p)->next);
+        }
+
+        /* put n intot hash table */
+        HashNode * newNode = (HashNode *)malloc(sizeof(HashNode));
+        newNode->key = n;
+        newNode->next = NULL;
+
+        *p = newNode;
+
+        sum = calcSquareSum(n);
+        if(sum == 1) {
+            bHappy = true;
+            bExit = true;
+        }
+        else {
+            n = sum;
+            
+        }
+    }
+
+    return bHappy;
+}
+```
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>
diff --git a/problems/0349.两个数组的交集.md b/problems/0349.两个数组的交集.md
index 82be1829..45f19b6e 100644
--- a/problems/0349.两个数组的交集.md
+++ b/problems/0349.两个数组的交集.md
@@ -281,6 +281,38 @@ impl Solution {
     }
 }
 ```
+
+C:
+```C
+int* intersection1(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
+
+    int nums1Cnt[1000] = {0};
+    int lessSize = nums1Size < nums2Size ? nums1Size : nums2Size;
+    int * result = (int *) calloc(lessSize, sizeof(int));
+    int resultIndex = 0;
+    int* tempNums;
+    
+    int i;
+
+    /* Calculate the number's counts for nums1 array */
+    for(i = 0; i < nums1Size; i ++) {
+        nums1Cnt[nums1[i]]++;
+    }
+
+    /* Check if the value in nums2 is existing in nums1 count array */
+    for(i = 0; i < nums2Size; i ++) {
+        if(nums1Cnt[nums2[i]] > 0) {
+            result[resultIndex] = nums2[i];
+            resultIndex ++;
+            /* Clear this count to avoid duplicated value */
+            nums1Cnt[nums2[i]] = 0;
+        }
+    }
+    * returnSize = resultIndex;
+    return result;
+}
+```
+
 ## 相关题目
 
 * 350.两个数组的交集 II
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index 15e096a0..55625130 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -276,7 +276,7 @@ func search(nums []int, target int) int {
 ```
 
 **JavaScript:**
-（版本一）左闭右闭区间
+（版本一）左闭右闭区间 [left, right]
 
 ```js
 /**
@@ -285,10 +285,12 @@ func search(nums []int, target int) int {
  * @return {number}
  */
 var search = function(nums, target) {
+    // right是数组最后一个数的下标，num[right]在查找范围内，是左闭右闭区间
     let left = 0, right = nums.length - 1;
-    // 使用左闭右闭区间
+    // 当left=right时，由于nums[right]在查找范围内，所以要包括此情况
     while (left <= right) {
         let mid = left + Math.floor((right - left)/2);
+        // 如果中间数大于目标值，要把中间数排除查找范围，所以右边界更新为mid-1；如果右边界更新为mid，那中间数还在下次查找范围内
         if (nums[mid] > target) {
             right = mid - 1;  // 去左面闭区间寻找
         } else if (nums[mid] < target) {
@@ -300,7 +302,7 @@ var search = function(nums, target) {
     return -1;
 };
 ```
-（版本二）左闭右开区间
+（版本二）左闭右开区间 [left, right)
 
 ```js
 /**
@@ -309,10 +311,13 @@ var search = function(nums, target) {
  * @return {number}
  */
 var search = function(nums, target) {
-    let left = 0, right = nums.length;
-    // 使用左闭右开区间 [left, right)
+    // right是数组最后一个数的下标+1，nums[right]不在查找范围内，是左闭右开区间
+    let left = 0, right = nums.length;    
+    // 当left=right时，由于nums[right]不在查找范围，所以不必包括此情况
     while (left < right) {
         let mid = left + Math.floor((right - left)/2);
+        // 如果中间值大于目标值，中间值不应在下次查找的范围内，但中间值的前一个值应在；
+        // 由于right本来就不在查找范围内，所以将右边界更新为中间值，如果更新右边界为mid-1则将中间值的前一个值也踢出了下次寻找范围
         if (nums[mid] > target) {
             right = mid;  // 去左区间寻找
         } else if (nums[mid] < target) {