算法（一）：排序与查找算法

一：二分查找

非递归版本

def binary_search_non_recursive(arr, target):
    low = 0
    high = len(arr) - 1

    while low <= high:
        # 计算中间索引
        mid = (low + high) // 2

        # 如果中间元素等于目标值，返回中间索引
        if arr[mid] == target:
            return mid
        # 如果中间元素大于目标值，更新 high 为 mid - 1，在左半部分继续查找
        elif arr[mid] > target:
            high = mid - 1
        # 如果中间元素小于目标值，更新 low 为 mid + 1，在右半部分继续查找
        else:
            low = mid + 1

    # 循环结束后仍未找到目标值，返回 -1
    return -1

# 测试代码
arr = [1, 3, 5, 7, 9, 11, 13]
target = 7
result = binary_search_non_recursive(arr, target)
if result != -1:
    print(f"目标值 {target} 在列表中的索引是 {result}")
else:
    print(f"目标值 {target} 不在列表中")

递归版本：
 

def binary_search_recursive(arr, target, low, high):
    # 如果 low 大于 high，说明目标值不在列表中
    if low > high:
        return -1

    # 计算中间索引
    mid = (low + high) // 2

    # 如果中间元素等于目标值，返回中间索引
    if arr[mid] == target:
        return mid
    # 如果中间元素大于目标值，在左半部分继续查找
    elif arr[mid] > target:
        return binary_search_recursive(arr, target, low, mid - 1)
    # 如果中间元素小于目标值，在右半部分继续查找
    else:
        return binary_search_recursive(arr, target, mid + 1, high)

# 测试代码
arr = [1, 3, 5, 7, 9, 11, 13]
target = 7
result = binary_search_recursive(arr, target, 0, len(arr) - 1)
if result != -1:
    print(f"目标值 {target} 在列表中的索引是 {result}")
else:
    print(f"目标值 {target} 不在列表中")

观察二者可以发现，非递归版本使用了while循环，递归版本则没有

二：
冒泡排序：
非递归版本

def bubble_sort_non_recursive(arr):
    n = len(arr)
    # 外层循环控制排序的轮数
    for i in range(n):
        # 标记是否发生交换
        swapped = False
        # 内层循环进行相邻元素的比较和交换
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                # 交换元素位置
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        # 如果没有发生交换，说明数组已经有序，提前结束排序
        if not swapped:
            break
    return arr

# 测试代码
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort_non_recursive(arr)
print("非递归冒泡排序结果:", sorted_arr)

递归版本：
 

def bubble_sort_recursive(arr, n):
    # 基本情况：如果数组长度为 1，直接返回
    if n == 1:
        return arr
    # 标记是否发生交换
    swapped = False
    # 进行相邻元素的比较和交换
    for i in range(n - 1):
        if arr[i] > arr[i + 1]:
            arr[i], arr[i + 1] = arr[i + 1], arr[i]
            swapped = True
    # 如果没有发生交换，说明数组已经有序，直接返回
    if not swapped:
        return arr
    # 递归调用，对前 n-1 个元素进行排序
    return bubble_sort_recursive(arr, n - 1)

# 测试代码
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort_recursive(arr, len(arr))
print("递归冒泡排序结果:", sorted_arr)

观察可以发现：递归版本的冒泡排序不需要使用双层循环，但是空间复杂度均为O（n^ 2）

三：
快速排序：

是对冒泡排序的改进，采用分治法，选择一个基准元素，使得数组左边小于基准元素，右边大于基准元素，对两边进行递归的快速排序

递归

def quick_sort_recursive(arr):
    if len(arr) <= 1:
        return arr
    # 选择第一个元素作为基准元素
    pivot = arr[0]
    # 小于基准元素的元素组成的列表
    left = [x for x in arr[1:] if x <= pivot]
    # 大于基准元素的元素组成的列表
    right = [x for x in arr[1:] if x > pivot]
    # 递归地对左右两部分进行排序，并合并结果
    return quick_sort_recursive(left) + [pivot] + quick_sort_recursive(right)

# 测试代码
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort_recursive(arr)
print("递归快速排序结果:", sorted_arr)