Add Python code (Chapter of searching)

to the docs.

codes/python/chapter_searching/binary_search.py

@@ -13,14 +13,14 @@ def binary_search(nums, target):
     # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
     i, j = 0, len(nums) - 1
     while i <= j:
-        m = (i + j) // 2  # 计算中点索引 m
-        if nums[m] < target:  # 此情况说明 target 在区间 [m+1, j] 中
+        m = (i + j) // 2        # 计算中点索引 m
+        if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j] 中
             i = m + 1
         elif nums[m] > target:  # 此情况说明 target 在区间 [i, m-1] 中
             j = m - 1
         else:
-            return m  # 找到目标元素，返回其索引
-    return -1  # 未找到目标元素，返回 -1
+            return m            # 找到目标元素，返回其索引
+    return -1                   # 未找到目标元素，返回 -1
 
 
 """ 二分查找（左闭右开） """
@@ -29,16 +29,17 @@ def binary_search1(nums, target):
     i, j = 0, len(nums)
     # 循环，当搜索区间为空时跳出（当 i = j 时为空）
     while i < j:
-        m = (i + j) // 2  # 计算中点索引 m
-        if nums[m] < target:  # 此情况说明 target 在区间 [m+1, j) 中
+        m = (i + j) // 2        # 计算中点索引 m
+        if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j) 中
             i = m + 1
         elif nums[m] > target:  # 此情况说明 target 在区间 [i, m) 中
             j = m
-        else:  # 找到目标元素，返回其索引
+        else:                   # 找到目标元素，返回其索引
             return m
-    return -1  # 未找到目标元素，返回 -1
+    return -1                   # 未找到目标元素，返回 -1
 
 
+""" Driver Code """
 if __name__ == '__main__':
     target = 6
     nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92]
@@ -46,6 +47,7 @@ if __name__ == '__main__':
     # 二分查找（双闭区间）
     index = binary_search(nums, target)
     print("目标元素 6 的索引 = ", index)
+    
     # 二分查找（左闭右开）
     index = binary_search1(nums, target)
     print("目标元素 6 的索引 = ", index)

codes/python/chapter_searching/hashing_search.py

@@ -9,33 +9,37 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 """ 哈希查找（数组） """
-def hashing_search(map,target):
+def hashing_search(mapp, target):
     # 哈希表的 key: 目标元素，value: 索引
     # 若哈希表中无此 key ，返回 -1
-    return map.get(target,-1)
+    return mapp.get(target, -1)
 
 """  哈希查找（链表） """
-def hashing_search1(map,target):
-    # 哈希表的 key: 目标元素，value: 节点对象
+def hashing_search1(mapp, target):
+    # 哈希表的 key: 目标元素，value: 结点对象
     # 若哈希表中无此 key ，返回 -1
-    return map.get(target,-1)
+    return mapp.get(target, -1)
 
-if __name__=='__main__':
-    target=3
+
+""" Driver Code """
+if __name__ == '__main__':
+    target = 3
+    
     # 哈希查找（数组）
-    nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
-    map=dict()                  # 初始化哈希表
+    nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+    # 初始化哈希表
+    mapp = {}
     for i in range(len(nums)):
-        map[nums[i]]=i          # key: 元素，value: 索引
-    index=hashing_search(map,target)
-    print("目标元素 3 的索引 = " ,index)
+        mapp[nums[i]] = i       # key: 元素，value: 索引
+    index = hashing_search(mapp, target)
+    print("目标元素 3 的索引 =", index)
 
     # 哈希查找（链表）
-    head=list_to_linked_list(nums)
-    map1=dict()                 # 初始化哈希表
+    head = list_to_linked_list(nums)
+    # 初始化哈希表
+    map1 = {}
     while head:
-        map1[head.val]=head      # key: 结点值，value: 结点
-        head=head.next
-
-    node=hashing_search1(map1,target)
-    print("目标结点值 3 的对应结点对象为 " , node)
+        map1[head.val] = head  # key: 结点值，value: 结点
+        head = head.next
+    node = hashing_search1(map1, target)
+    print("目标结点值 3 的对应结点对象为", node)

codes/python/chapter_searching/linear_search.py

@@ -9,30 +9,33 @@ sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
 """ 线性查找（数组） """
-def linear_search(nums,target):
+def linear_search(nums, target):
     # 遍历数组
     for i in range(len(nums)):
-        if nums[i]==target: # 找到目标元素，返回其索引
+        if nums[i] == target:  # 找到目标元素，返回其索引
             return i
-    return -1               # 未找到目标元素，返回 -1
+    return -1                  # 未找到目标元素，返回 -1
 
 """ 线性查找（链表） """
-def linear_search_by_link(head,target):
+def linear_search1(head, target):
     # 遍历链表
     while head:
-        if head.val==target:    # 找到目标结点，返回之
-            return  head
-        head=head.next
-    return None         # 未找到目标结点，返回 None (Python为None)
+        if head.val == target: # 找到目标结点，返回之
+            return head
+        head = head.next
+    return None                # 未找到目标结点，返回 None
 
-if __name__=='__main__':
-    target=3
+
+""" Driver Code """
+if __name__ == '__main__':
+    target = 3
+    
     # 在数组中执行线性查找
-    nums=[1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
-    index=linear_search(nums,target)
-    print("目标元素 3 的索引 = " ,index)
+    nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
+    index = linear_search(nums, target)
+    print("目标元素 3 的索引 =", index)
 
     # 在链表中执行线性查找
-    head=list_to_linked_list(nums)
-    node=linear_search_by_link(head,target)
-    print("目标结点值 3 的对应结点对象为 " ,node)
+    head = list_to_linked_list(nums)
+    node = linear_search1(head, target)
+    print("目标结点值 3 的对应结点对象为", node)

docs/chapter_searching/binary_search.md

@@ -105,7 +105,19 @@ $$
 === "Python"
 
     ```python title="binary_search.py"
-
+    """ 二分查找（双闭区间） """
+    def binary_search(nums, target):
+        # 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+        i, j = 0, len(nums) - 1
+        while i <= j:
+            m = (i + j) // 2        # 计算中点索引 m
+            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j] 中
+                i = m + 1
+            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m-1] 中
+                j = m - 1
+            else:
+                return m            # 找到目标元素，返回其索引
+        return -1                   # 未找到目标元素，返回 -1
     ```
 
 === "Go"
@@ -189,7 +201,20 @@ $$
 === "Python"
 
     ```python title="binary_search.py"
-
+    """ 二分查找（左闭右开） """
+    def binary_search1(nums, target):
+        # 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+        i, j = 0, len(nums)
+        # 循环，当搜索区间为空时跳出（当 i = j 时为空）
+        while i < j:
+            m = (i + j) // 2        # 计算中点索引 m
+            if nums[m] < target:    # 此情况说明 target 在区间 [m+1, j) 中
+                i = m + 1
+            elif nums[m] > target:  # 此情况说明 target 在区间 [i, m) 中
+                j = m
+            else:                   # 找到目标元素，返回其索引
+                return m
+        return -1                   # 未找到目标元素，返回 -1
     ```
 
 === "Go"
@@ -262,8 +287,8 @@ $$
 === "Python"
 
     ```py title=""
-    # Python 中的数字理论上可以无限大（取决于内存）
-    # 因此无需考虑大数越界问题 
+    # Python 中的数字理论上可以无限大（取决于内存大小）
+    # 因此无需考虑大数越界问题
     ```
 
 === "Go"

docs/chapter_searching/hashing_search.md

@@ -43,7 +43,11 @@ comments: true
 === "Python"
 
     ```python title="hashing_search.py"
-
+    """ 哈希查找（数组） """
+    def hashing_search(mapp, target):
+        # 哈希表的 key: 目标元素，value: 索引
+        # 若哈希表中无此 key ，返回 -1
+        return mapp.get(target, -1)
     ```
 
 === "Go"
@@ -107,7 +111,11 @@ comments: true
 === "Python"
 
     ```python title="hashing_search.py"
-
+    """  哈希查找（链表） """
+    def hashing_search1(mapp, target):
+        # 哈希表的 key: 目标元素，value: 结点对象
+        # 若哈希表中无此 key ，返回 -1
+        return mapp.get(target, -1)
     ```
 
 === "Go"

docs/chapter_searching/linear_search.md

@@ -47,7 +47,13 @@ comments: true
 === "Python"
 
     ```python title="linear_search.py"
-
+    """ 线性查找（数组） """
+    def linear_search(nums, target):
+        # 遍历数组
+        for i in range(len(nums)):
+            if nums[i] == target:  # 找到目标元素，返回其索引
+                return i
+        return -1                  # 未找到目标元素，返回 -1
     ```
 
 === "Go"
@@ -119,7 +125,14 @@ comments: true
 === "Python"
 
     ```python title="linear_search.py"
-
+    """ 线性查找（链表） """
+    def linear_search1(head, target):
+        # 遍历链表
+        while head:
+            if head.val == target: # 找到目标结点，返回之
+                return head
+            head = head.next
+        return None                # 未找到目标结点，返回 None
     ```
 
 === "Go"