Day 21 : 归并排序，二分查找法

2020/10/13

归并排序

merge_sort 其实就是把无序的序列不断2分。拆分到只有一个元素时 ，才开始合并。在合并的过程中开始比较大小.。

def merge_sort(alist):
    n = len(alist)
    if n <= 1:
        return alist
    mid = n // 2
    left_list = merge_sort(alist[:mid])
    right_list = merge_sort(alist[mid:])

    left_pointer, right_pointer = 0, 0
    result = []
    while left_pointer < len(left_list) and right_pointer < len(right_list):
        if left_list[left_pointer] < right_list[right_pointer]:
            result.append(left_list[left_pointer])
            left_pointer += 1
        else:
            result.append(right_list[right_pointer])
            right_pointer += 1

    result += left_list[left_pointer:]
    result += right_list[right_pointer:]
    return result


if __name__ == "__main__":
    a = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print(a)
    li = merge_sort(a)
    print(a)
    print(li)

时间复杂度
最优时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
稳定性：稳定

注意：必修，必须会！！快排法 因为应用场景最多。

时间复杂度对比表

二分查找法

常见的查找方法有： 顺序查找法，二分法，二叉树法，哈希方法。
二分法必须作用到顺序表里，因为每个元素必须有他自己的索引，对于链表来说 就不能用二分法。
优点是 比较次数少，查找速度快，平均性能好
缺点是 要求待查表为有序表，且插入删除困难。

非递归方法实现

def binary_search(alist, item):
      first = 0
      last = len(alist)-1
      while first<=last:
          midpoint = (first + last)/2
          if alist[midpoint] == item:
              return True
          elif item < alist[midpoint]:
              last = midpoint-1
          else:
              first = midpoint+1
    return False
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

递归方法实现

def binary_search(alist, item):
    if len(alist) == 0:
        return False
    else:
        midpoint = len(alist)//2
        if alist[midpoint]==item:
          return True
        else:
          if item<alist[midpoint]:
            return binary_search(alist[:midpoint],item)
          else:
            return binary_search(alist[midpoint+1:],item)

testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))