Algorithm & Data structure

38. 用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)
    

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

    # 短小精悍 真美 简直写诗   哈哈哈
    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
    

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

    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)
    
    

41. 写一个冒泡排序

    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))
    

42. 写一个快速排序

    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))
    

43. 单链表反转

    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()
    

44. 堆排序