Python函数中列表变量的陷阱：理解原地修改与变量重赋值

from typing import List

def merge_problematic(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    尝试原地修改 nums1，但存在问题。
    """
    if m + n == m:
        # 这个分支的逻辑与核心问题无关，但它也涉及重赋值
        nums1 = nums2 if m == 0 else nums1
    else:
        # 核心问题所在：这行代码创建了一个新列表并重赋值给局部变量 nums1
        nums1 = nums1[:m] # nums1 现在指向一个新列表 [nums1[0], ..., nums1[m-1]]
        nums1.extend(nums2) # 修改的是这个新列表

    print('函数内部重赋值后的 nums1:', nums1) # 此时打印的是新列表
    nums1.sort() # 对新列表进行排序
    print('函数内部排序后的 nums1:', nums1) # 此时打印的是排序后的新列表

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_problematic(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)

def merge_in_place_clear_extend(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    通过 clear() 和 extend() 方法实现列表的原地修改。
    """
    # 1. 获取需要合并的元素
    # 假设我们只需要 nums1 的前 m 个元素和 nums2 的前 n 个元素
    merged_elements = nums1[:m] + nums2[:n]
    merged_elements.sort() # 对合并后的元素进行排序

    # 2. 清空原始 nums1 列表
    nums1.clear() # 这会清空 original_nums1 的内容，但 original_nums1 仍然指向同一个列表对象

    # 3. 将排序后的元素添加到原始 nums1 列表
    nums1.extend(merged_elements) # 这会将元素添加到 original_nums1 中

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_in_place_clear_extend(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

def merge_in_place_slice_assignment(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    通过切片赋值 nums1[:] = ... 实现列表的原地修改。
    """
    # 1. 获取需要合并的元素
    merged_elements = nums1[:m] + nums2[:n]
    merged_elements.sort() # 对合并后的元素进行排序

    # 2. 使用切片赋值将排序后的元素替换掉原始 nums1 的内容
    nums1[:] = merged_elements # 这会替换 original_nums1 的所有元素

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_in_place_slice_assignment(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

def merge_leetcode_style_in_place(nums1: List[int], m: int, nums2: List[int], n: int) -> None:
    """
    针对 nums1 预留足够空间（m+n 长度）的合并有序数组问题，使用双指针原地合并。
    """
    # 初始化三个指针：
    # p1 指向 nums1 中有效元素的最后一个位置
    # p2 指向 nums2 中最后一个元素的位置
    # write_idx 指向 nums1 中合并后元素的写入位置 (从末尾开始)
    p1 = m - 1
    p2 = n - 1
    write_idx = m + n - 1

    # 从后向前遍历，比较 nums1 和 nums2 的元素，将较大的放入 nums1 的末尾
    while p1 >= 0 and p2 >= 0:
        if nums1[p1] > nums2[p2]:
            nums1[write_idx] = nums1[p1]
            p1 -= 1
        else:
            nums1[write_idx] = nums2[p2]
            p2 -= 1
        write_idx -= 1

    # 如果 nums2 中还有剩余元素（说明 nums2 中有比 nums1 中所有元素都小的），
    # 将它们复制到 nums1 的前部
    while p2 >= 0:
        nums1[write_idx] = nums2[p2]
        p2 -= 1
        write_idx -= 1

    # 如果 nums1 中还有剩余元素（p1 >= 0），它们已经位于正确的位置，无需额外处理。

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0] # nums1 长度为 6 (m+n)
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
merge_leetcode_style_in_place(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1:', original_nums1)
# 输出: 调用后 original_nums1: [1, 2, 2, 3, 5, 6]

def merge_and_return_new_list(nums1: List[int], m: int, nums2: List[int], n: int) -> List[int]:
    """
    合并列表并返回一个新的排序后的列表，不修改原始列表。
    """
    # 1. 获取需要合并的元素
    merged_elements = nums1[:m] + nums2[:n]
    # 2. 使用 sorted() 函数返回一个新的排序列表
    sorted_merged_list = sorted(merged_elements)
    return sorted_merged_list

# 示例调用
original_nums1 = [1, 2, 3, 0, 0, 0]
m_val = 3
nums2_val = [2, 5, 6]
n_val = 3

print('调用前 original_nums1:', original_nums1)
new_result_list = merge_and_return_new_list(original_nums1, m_val, nums2_val, n_val)
print('调用后 original_nums1 (未改变):', original_nums1)
print('新生成的合并列表:', new_result_list)
# 输出:
# 调用后 original_nums1 (未改变): [1, 2, 3, 0, 0, 0]
# 新生成的合并列表: [1, 2, 2, 3, 5, 6]