Algorithm & Data structure

1. 用Python实现一个二分查找的函数

   def binary_search(arr, num):
       n = len(arr)
       left = 0
       right = n - 1  # 最右边的index
       while left <= right:
           mid = (left + right) // 2
           if num == arr[mid]:
               return "index:" + str(mid)
           elif num < arr[mid]:
               right = mid - 1  # 比中间的小
           else:
               left = mid + 1  # 比中间的大
       return False  # 从这个循环里面跳出来说明木有找到，返回False
   
   
   if __name__ == "__main__":
       lst = [1, 3, 4, 5, 7, 100]
       res = binary_search(lst, 7)
       print(res)

2. 找出列表中的重复数字

   # 短小精悍 真美 简直写诗   哈哈哈
   def duplication(arr):
       use_set=set()
       dup={}
       for key,value in enumerate(arr):   # 高级用法
           if value not in use_set:
               use_set.add(value)
           else:
               dup[key]=value
      return dup

3. 找出列表里面的单个数字(有且仅有一个单个数字)

   def find_single(arr):
       # 异或运算，相同为零，不同为一，任何数异或0还是任何数
       res = 0
       for item in arr:
           res ^= item
       if res == 0:
           print("没有落单数字")
       else:
           print("落单数字为:", res)
   
   
   if __name__ == "__main__":
       lst = [1, 2, 3, 4, 5, 2, 3, 4, 5]
       find_single(lst)
   

4. 写一个冒泡排序

   def buble_sort(arr):
       n = len(arr)
       if n <= 1:
           return arr
       isneedexchange = False  # 标记一下是否交换了的
       for i in range(n - 1):  # n个数排n-1趟
           for j in range(n - i - 1):
               # 这个位置为什么是n-i-1呢？当i=0时，否者会溢出 ，试一下就知道了。
               if arr[j] > arr[j + 1]:
                   isneedexchange = True  # 表示交换过了
                   arr[j], arr[j + 1] = arr[j + 1], arr[j]
           if isneedexchange == False:
               break
       return arr
   
   
   if __name__ == "__main__":
       lst = [9, 6, 8, 3, 2, 4, 1]
       print(buble_sort(lst))

5. 写一个快速排序

   def quick_sort(arr):
       n = len(arr)
       if n <= 1:
           return arr
       low = []
       mid = []
       high = []
       splitdata = arr[0]
       mid.append(splitdata)
       for i in range(1, n):
           # the first element has been used
           if arr[i] < splitdata:
               low.append(arr[i])
           elif arr[i] == splitdata:
               mid.append(arr[i])
           else:
               high.append(arr[i])
       low, high = quick_sort(low), quick_sort(high)
       return low + mid + high
   
   
   if __name__ == "__main__":
       lst = [9, 6, 8, 3, 2, 4, 1]
       print(quick_sort(lst))

6. 单链表反转

   class Node:
       def __init__(self, val=None):
           self.val = val
           self.next = None
   
   
   class SingleLinkList:
       def __init__(self, head=None):
           self.head = head
   
       def add(self, val):
           '''
           给链表添加元素,要先判断是否有头结点
           没有头结点的话,当前节点作为头结点,否者添加到最后
           '''
           node = Node(val)  # 类实例化
           if self.head:
               cur = self.head
               while cur.next:  # 表示下一个节点存在
                   # 不存在的话 cur就是最后一个节点
                   cur = cur.next
               cur.next = node
           else:
               self.head = node
   
       def traversal(self):
           cur = self.head
           print(cur.val, end=' ')
           while cur.next:
               cur = cur.next
               print(cur.val, end=' ')
   
       def reverse(self):
           cur = self.head
           pre = None
           while cur:
               post = cur.next
               cur.next = pre
               pre = cur
               cur = post
           self.head = pre  # 这里面当cur不存在的情况下，找前一个  
   
   
   if __name__ == "__main__":
       ssl = SingleLinkList()  # 实例化
       ssl.add(9)
       ssl.add(6)
       ssl.add(8)
       ssl.add(3)
       ssl.add(2)
       ssl.add(4)
       ssl.add(1)
       ssl.traversal()
       print()
       ssl.reverse()
       ssl.traversal()

7. 堆排序