Leetcode.算法复习

1. 排序算法

 常用排序算法python实现：

"""
    排序算法
"""


# 冒泡排序
def bubbleSort(nums):
    for i in range(len(nums) - 1): # 遍历 len(nums)-1 次
        for j in range(len(nums) - i - 1): # 已排好序的部分不用再次遍历
            if nums[j] > nums[j+1]:
                nums[j], nums[j+1] = nums[j+1], nums[j] # Python 交换两个数不用中间变量
    return nums


# 选择排序
def selectionSort(nums):
    for i in range(len(nums) - 1):  # 遍历 len(nums)-1 次
        minIndex = i
        for j in range(i + 1, len(nums)):
            if nums[j] < nums[minIndex]:  # 更新最小值索引
                minIndex = j
        nums[i], nums[minIndex] = nums[minIndex], nums[i] # 把最小数交换到前面
    return nums


# 快速排序
def quicksort(arr, l, r):
    if l >= r:
        return
    base = l
    l_const, r_const = l, r
    while l < r:
        while l < r and arr[r] >= arr[base]:
            r -= 1
        while l < r and arr[l] <= arr[base]:
            l += 1
        arr[l], arr[r] = arr[r], arr[l]
    arr[base], arr[l] = arr[l], arr[base]
    quicksort(arr, l_const, l - 1)
    quicksort(arr, l + 1, r_const)
    return arr


# 归并排序
def merge_sort(arr):
    def merge(left, right):
        l = r = 0
        newlist = []
        while l < len(left) and r < len(right):
            if left[l] <= right[r]:
                newlist.append(left[l])
                l += 1
            else:
                newlist.append(right[r])
                r += 1
        newlist = newlist + left[l:] + right[r:]
        return newlist

    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)


# 堆排序
def heap_sort(array):
    def big_heap(array, start, end):
        root = start
        # 左孩子的索引
        child = root * 2 + 1
        while child <= end:
            # 节点有右子节点，并且右子节点的值大于左子节点，则将child变为右子节点的索引
            if child + 1 <= end and array[child] < array[child + 1]:
                child += 1
            if array[root] < array[child]:
                # 交换节点与子节点中较大者的值
                array[root], array[child] = array[child], array[root]
                # 交换值后，如果存在孙节点，则将root设置为子节点，继续与孙节点进行比较
                root = child
                child = root * 2 + 1
            else:
                break
    first = len(array) // 2 - 1
    for start in range(first, -1, -1):
        # 从下到上，从右到左对每个非叶节点进行调整，循环构建成大顶堆
        big_heap(array, start, len(array) - 1)

    for end in range(len(array) - 1, 0, -1):
        # 交换堆顶和堆尾的数据
        array[0], array[end] = array[end], array[0]
        # 重新调整完全二叉树，构造成大顶堆
        big_heap(array, 0, end - 1)
    return array


def main():
    arr = [8,349,6,5,4]
    res1 = bubbleSort(arr)
    res2 = selectionSort(arr)
    res3 = quicksort(arr,0,len(arr)-1)
    res4 = merge_sort(arr)
    res5 = heap_sort(arr)
    print(res1)
    print(res5)


if __name__ == "__main__":
    main()

2. 查找算法

二分查找

def binarySearch(list, target):
	left = 0
	right = len(list) - 1  
	#在list[left...right]里查找target，注意是左闭右闭
	while left <= right:
		mid = (right + left) // 2    #取中间元素索引
		if list[mid] == target:
			return mid
		elif target > list[mid]
			left = mid + 1     #到list[mid + 1 ...right]里查找
		else:  #target < list[mid]
			right = mid - 1    #到list[left ...mid - 1]里查找
return -1    #未找到target元素