实现带合并函数的Counting Version算法时遇'int不可迭代'错误求助

我来帮你排查这个int object is not iterable的错误，咱们一步步拆解问题并修复代码：

错误根源分析 #

你遇到的核心错误来自sort_and_count函数的基例返回值不匹配，同时代码里还有几处逻辑漏洞会导致功能失效，下面逐个说明：

具体问题与修复方案 #

1. sort_and_count基例返回值错误

当len(L) == 1时，你只返回了整数0，但递归调用时你期望接收的是**(逆序对数量, 排序后的列表)**这样的元组。比如(rA,A) = sort_and_count(A)，如果A长度为1，sort_and_count(A)返回单个整数0，Python尝试把这个int解包成两个值，就会抛出int object is not iterable的错误。
修复： 基例改为返回元组：

if len(L) == 1:
    return (0, L)  # 同时返回逆序对数量和原列表（长度1无需排序）

2. 数组分割时漏掉最后一个元素

在sort_and_count中，分割B数组的循环是for i in range(size2,size-1)，range是左闭右开区间，这会导致最后一个元素（索引size-1）没有被添加到B里。
修复： 把循环改成：

for i in range(size2, size):
    B.append(L[i])

3. mergesort递归调用未接收返回值

你的mergesort函数本身会返回排序后的列表，但递归调用时你直接写了mergesort(liste_1_temp)，没有把返回的排序结果赋值给原变量，导致后续合并的是未排序的原数组片段，排序逻辑完全失效。
修复： 递归调用时接收返回值：

liste_1_temp = mergesort(liste_1_temp)
liste_2_temp = mergesort(liste_2_temp)

4. merge_and_count循环逻辑错误

• 原循环只判断了i < len(A)，没考虑j是否超出B的长度，当B的元素都处理完后，访问B[j]会触发索引越界；
• 当A[i] > B[j]时错误地重置了i=0，这会导致无限循环或计数完全错误。
  修复： 调整循环逻辑，正确合并两个有序数组并统计逆序对：

def merge_and_count(A,B):
    i = 0
    j = 0
    count = 0
    C = []
    # 同时遍历两个有序数组
    while i < len(A) and j < len(B):
        if A[i] > B[j]:
            C.append(B[j])
            count += len(A) - i  # 左数组剩余元素都大于当前B[j]
            j += 1
        else:
            C.append(A[i])
            i += 1
    # 处理剩余元素
    C.extend(A[i:])
    C.extend(B[j:])
    return count, C

修正后的完整代码 #

def mergesort(lst): 
    """Fonction qui classe les nombres de la liste par ordre croissant."""
    taille = len(lst)
    liste_1_temp = []
    liste_2_temp = []
    if len(lst) > 1:
        for i in range(0, taille//2):
            liste_1_temp.append(lst[i])
        for i in range(taille//2, taille):
            liste_2_temp.append(lst[i])
        # 接收递归排序后的结果
        liste_1_temp = mergesort(liste_1_temp)
        liste_2_temp = mergesort(liste_2_temp)
        
        i = 0
        j = 0
        k = 0
        while i < len(liste_1_temp) and j < len(liste_2_temp):
            if liste_1_temp[i] < liste_2_temp[j]:
                lst[k] = liste_1_temp[i]
                i += 1
                k += 1
            else:
                lst[k] = liste_2_temp[j]
                j += 1
                k += 1
        while i < len(liste_1_temp):
            lst[k] = liste_1_temp[i]
            i += 1
            k += 1
        while j < len(liste_2_temp):
            lst[k] = liste_2_temp[j]
            j += 1
            k += 1
    return lst

def merge_and_count(A,B):
    """Fonction qui renvoie le nombre d'inversions et le tableau fusionné trié."""
    i = 0
    j = 0
    count = 0
    C = []
    while i < len(A) and j < len(B):
        if A[i] > B[j]:
            C.append(B[j])
            count += len(A) - i
            j += 1
        else:
            C.append(A[i])
            i += 1
    C.extend(A[i:])
    C.extend(B[j:])
    return count, C

def sort_and_count(L):
    """Fonction qui calcule le nombre total d'inversions et renvoie le tableau trié."""
    if len(L) == 1:
        return (0, L)  # 返回元组，匹配递归解包需求
    size = len(L)
    size2 = size // 2
    A = []
    B = []
    for i in range(0, size2):
        A.append(L[i])
    for i in range(size2, size):  # 修复range结束值，避免漏掉最后一个元素
        B.append(L[i])
    
    (rA, A_sorted) = sort_and_count(A)
    (rB, B_sorted) = sort_and_count(B)
    (r, merged) = merge_and_count(A_sorted, B_sorted)
    
    return (rA + rB + r, merged)

内容的提问来源于stack exchange，提问作者user5335342