python算法详解pdf百度云,python算法详解电子版

最新推荐文章于 2025-04-28 14:23:19 发布

小狗AI

最新推荐文章于 2025-04-28 14:23:19 发布

阅读量1k

点赞数 25

文章标签： python 排序算法算法人工智能

本文链接：https://blog.youkuaiyun.com/ai_lover_cat/article/details/136392405

版权

大家好，给大家分享一下你也能看得懂的python算法书pdf，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

Source code download: 本文相关源码

一、排序算法 Sorting algorithms

插入排序 (Insertion sort)
归并排序 (Merge sort）
堆排序 Heap sort
快速排序 Quick sort

插入排序 (Insertion sort)

第n个元素依次比较前n-1个已排序好的数组元素直到插入相应位置

平均时间复杂度：O(n²)
空间复杂度：O(1)

def insertion_sort(seq):
	for j in range(1, len(seq)):
		key = seq[j]
		i = j - 1
		while i >= 0 and seq[i] > key:
			seq[i + 1] = seq[i]
			i = i - 1
		seq[i + 1] = key
	return seq

归并排序 (Merge sort)

分治法；连续二等分后子序列进行比较排序到一个新数组之中，再两两合并

时间复杂度：O(nlogn)
最坏空间复杂度：O(n)

def merge_sort(arr):
    if len(arr) == 1:
        return arr

    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    return marge(merge_sort(left), merge_sort(right))

def marge(left, right):
    result = []
    # 两个数列都有值
    while len(left) > 0 and len(right) > 0:
        # 左右两个数列第一个最小放前面
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    # 只有一个数列中还有值，直接添加
    result += left
    result += right
    return result


//或者用 指针
def merge(left,right):
    res = []
    i,j =0, 0
    while i<len(left_half) and j<len(right_half):
        if left_half[i] >= right_half[j]:
            res.append(right_half[j])
            j+=1
        else:
            res.append(left_half[i])
            i+=1
    if i==len(left_half) and j<len(right_half):
        res.extend(right_half[j:])
    if i<len(left_half) and j==len(right_half):
        res.extend(left_half[i:]) 

    return res

堆排序 Heap sort

堆是一种完全二叉树 构建大顶堆maxheap -> 交换根节点和末节点 -> 堆顶heapify再次形成大顶堆

时间复杂度：O(nlogn)

#由结点i开始向下max-heapify
def heapify(arr, n, i):
    largest = i
    left =  2*i+1 
    right = 2*i+2  

    if left<n and arr[left]>arr[largest]:
        largest= left
 
    if right<n and arr[right]>arr[largest]:
        largest= right
 
    if largest != i:
        arr[largest], arr[i]= arr[i],arr[largest]        
        # Heapify the root.
        heapify(arr, n, largest)

#构建max heap (根节点大于子节点)
def maxheap(arr, n):
    for i in range(n//2 - 1, -1, -1):
        heapify(arr, n, i)

#堆排序
def heapSort(arr):
    n = len(arr)
    maxheap(arr, n)
 
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

快速排序 Quick Sort

选出一个基准值(pivot)，将数组分为两份：一份小于基准值，一份大于基准值，递归进行

平均时间复杂度：O(nlogn)
空间复杂度O(logn)

#方法一：一次遍历
def partition(arr, left, right):
    pivot = arr[right]
    i = left 
    for j in range(left, right):
        if arr[j] <= pivot:
            arr[j], arr[i] = arr[i], arr[j]
            i += 1
    arr[i], arr[right] = arr[right], arr[i]
    return i

def quickSort(arr, left, right):
    if left < right:
        p = partition(arr, left, right)
        quickSort(arr, left, p-1)
        quickSort(arr, p+1, right)


#方法二：迭代循环 （见参考）
def quick_sort_standord(array,low,high):
    ''' realize from book "data struct" of author 严蔚敏
    '''
    if low < high:
        key_index = partion(array,low,high)
        quick_sort_standord(array,low,key_index)
        quick_sort_standord(array,key_index+1,high)

def partion(array,low,high):
    key = array[low]
    while low < high:
        while low < high and array[high] >= key:
            high -= 1
        if low < high:
            array[low] = array[high]

        while low < high and array[low] < key:
            low += 1
        if low < high:
            array[high] = array[low]

    array[low] = key
    return low