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. 堆排序