python语言基本算法（自用-持续更新）

代码均来自网络搜索，拼凑起来，方便自用

排序算法：

1. 冒泡排序（Bubble Sort）

def bubble_sort(arr):
    n = len(arr)
 # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n - i - 1):
            # 遍历数组从 0 到 n-i-1
            # 交换如果元素比下一个元素大
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

2. 选择排序（Selection Sort）

def selection_sort(arr):
    n = len(arr)
    for i in range(n-1):
        min_idx = i
        for j in range(i+1, n):
            # 比较列表值大小，如果小则将下标替换到最小值处
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

3. 插入排序（Insertion Sort）

def insertion_sort(arr):
    n = len(arr)
    #每次循环中，key 变量被赋值为当前索引 i 对应的元素
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        #如果 arr[j]（即 key 前一个元素）大于 key，则将 arr[j] 向后移动一个位置
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            #j 减 1，继续比较 key 和它前一个元素
            j -= 1
        #一旦找到合适的位置或者 j 变为 -1（即 key 是目前找到的最小元素），key 将被插入到 arr[j + 1] 的位置
        arr[j + 1] = key

4. 快速排序（Quick Sort）

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]  # 选择基准点（pivot），这里选择第一个元素,arr[1:]表示切片操作，取索引1（第二个元素）开始到数组末尾的部分，当前元素 x 小于等于基准点 pivot）为真时，才会执行列表推导式内部的代码
        less = [x for x in arr[1:] if x <= pivot]  # 所有小于等于基准点的元素
        greater = [x for x in arr[1:] if x > pivot]  # 所有大于基准点的元素
        return quick_sort(less) + [pivot] + quick_sort(greater)  # 递归排序子序列并合并

5. 归并排序（Merge Sort）

#分左右列表，每个列表仅剩1个元素时进行合并排序，递归函数
def merge_sort(array):
    if len(array) == 1:
        return array
    left_array = merge_sort(array[:len(array) // 2])
    right_array = merge_sort(array[len(array) // 2:])
    return merge(left_array, right_array)
#合并左右列表
def merge(left_array, right_array):
    left_index, right_index, merge_array = 0, 0, list()
    while left_index < len(left_array) and right_index < len(right_array):
        if left_array[left_index] <= right_array[right_index]:
            merge_array.append(left_array[left_index])
            left_index += 1
        else:
            merge_array.append(right_array[right_index])
            right_index += 1
    merge_array = merge_array + left_array[left_index:] + right_array[right_index:]
    return merge_array

6. 堆排序（Heap Sort）

#一般升序采用大顶堆，降序采用小顶堆。例子为升序
def heapify(arr, n, i):
    largest = i  # 假设当前节点为最大值
    left = 2 * i + 1  # 左子节点
    right = 2 * i + 2  # 右子节点
    # 检查左子节点是否存在并且值大于当前最大值
    if left < n and arr[i] < arr[left]:
        largest = left
    # 检查右子节点是否存在并且值大于当前最大值
    if right < n and arr[largest] < arr[right]:
        largest = right
    # 如果找到更大的值，交换它与当前节点，并继续堆化
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)
def heap_sort(arr):
    n = len(arr)
    # 建堆过程，从最后一个非叶子节点开始调整堆，range(起始，结束，步长)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    # 排序过程
    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]  # 交换堆顶元素与最后一个元素
        heapify(arr, i, 0)  # 重新调整堆

搜索算法

7. 线性搜索（Linear Search）

def linear_search(arr, target):
    """
    线性搜索算法实现。
    参数:
    arr -- 要搜索的列表。
    target -- 要搜索的目标值。
    返回:
    目标值在列表中的索引，如果未找到则返回-1。
    """
    for index, value in enumerate(arr):
        if value == target:
            return index  # 如果找到目标值，返回其索引
    return -1  # 如果遍历完列表都没有找到目标值，返回-1

2. 二分搜索（Binary Search）

def binary_search(arr, target):
    """
    二分搜索算法实现。
    参数:
    arr -- 有序的列表。
    target -- 要搜索的目标值。
    返回:
    目标值在列表中的索引，如果未找到则返回-1。
    """
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2  # 计算中间索引
        mid_value = arr[mid]      # 获取中间元素的值
        if mid_value == target:
            return mid  # 找到目标值，返回索引
        elif mid_value < target:
            left = mid + 1  # 目标值在右半部分
        else:
            right = mid - 1  # 目标值在左半部分
    return -1  # 如果未找到目标值，返回-1

栈应用

查找有效的括号
给定一个只包括’(‘，’)‘，’{‘，’}‘，’[‘，’]'的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合
左括号必须以正确的顺序闭合

def check_func(check_str: str) -> bool:
    dic = {")": "(", "}": "{", "]": "["}
    stack = []
    for i in check_str:
        if stack and i in dic:
        	#stack[-1]当前列表中最后的元素
            if stack[-1] == dic[i]:
                stack.pop()
            else:
                return False
        else:
            stack.append(i)
    return not stack