Algorithm 我的mergesort代码在递归方面有问题吗？ def mergesort（A、左、右）：#输入大小为n 如果左==右： 返回 中间=（左+右）//2 合并排序（A、左、中） 合并排序（A、中、右） 合并（A、左、中、右） def合并（A、左、中、右）： L=A[左：中间+1] R=A[中间+1：右] lp=0 rp=0 开始p=0 当lp

当我运行代码时，它总是说“比较中超过了最大递归深度”，但我这里有停止标准。我不知道问题出在哪里：/

我从您的代码中了解到，

right

表示超出范围的索引，就像Python中的常见习惯一样

有三个问题：

• 基本情况应该是当范围中只有1个元素时。当

  left==right+1

  时会发生这种情况，因此如果

  条件错误，您的第一个
  。使用
  left==right
  您将得到一个无限递归，因为1大小的范围将被拆分为零大小的范围，并且。。。一个1号的范围。所以第二个将是另一个递归调用的原因，…等等。因此，将
  if
  条件更改为
  left+1>=right
  
  

• merge

  中的第一个语句在

  mid+1

  处分割范围，而这应该是

  mid

• 两条语句之后，您将0分配给

  start\p

  ，但请记住

  merge

  是通过一个范围调用的：

  left

  ，

  right

  。使用索引0意味着稍后您将在

  a[0]

  中写入一个可能超出给定范围的值。它应该是左侧的

  ，而不是0
  
  

因此，纠正这三个问题后，工作代码将变为：

def mergesort(A, left, right):  # Input size is n
    if left == right:
        return
    mid = (left + right)//2
    mergesort(A,left, mid)
    mergesort(A, mid, right)
    merge(A, left, mid, right)
    
def merge(A, left, mid, right):
    L = A[left:mid+1]
    R = A[mid+1:right]
    lp = 0 
    rp = 0 
    start_p = 0
    while lp < len(L) and rp < len(R):
        if L[lp] < R[rp]:
            A[start_p] = L[lp]
            start_p += 1
            lp += 1
        else:
            A[start_p] = R[rp]
            start_p += 1
            rp += 1
    while lp < len(L):
        A[start_p] = L[lp]
        start_p += 1
        lp += 1
    while rp < len(R):
        A[start_p] = R[rp]
        start_p += 1
        rp += 1
    return

def合并排序（A、左、右）：
如果左+1>=右：
返回
中间=（左+右）//2
合并排序（A、左、中）
合并排序（A、中、右）
合并（A、左、中、右）
def合并（A、左、中、右）：
L=A[左：中]
R=A[中间：右侧]
lp=0
rp=0
开始p=左#！！
当lp

我从您的代码中了解到，

right

表示超出范围的索引，就像Python中的常见习惯一样

有三个问题：

• 基本情况应该是当范围中只有1个元素时。当

  left==right+1

  时会发生这种情况，因此如果

  条件错误，您的第一个
  。使用
  left==right
  您将得到一个无限递归，因为1大小的范围将被拆分为零大小的范围，并且。。。一个1号的范围。所以第二个将是另一个递归调用的原因，…等等。因此，将
  if
  条件更改为
  left+1>=right
  
  

• merge

  中的第一个语句在

  mid+1

  处分割范围，而这应该是

  mid

• 两条语句之后，您将0分配给

  start\p

  ，但请记住

  merge

  是通过一个范围调用的：

  left

  ，

  right

  。使用索引0意味着稍后您将在

  a[0]

  中写入一个可能超出给定范围的值。它应该是左侧的

  ，而不是0
  
  

因此，纠正这三个问题后，工作代码将变为：

def mergesort(A, left, right):  # Input size is n
    if left == right:
        return
    mid = (left + right)//2
    mergesort(A,left, mid)
    mergesort(A, mid, right)
    merge(A, left, mid, right)
    
def merge(A, left, mid, right):
    L = A[left:mid+1]
    R = A[mid+1:right]
    lp = 0 
    rp = 0 
    start_p = 0
    while lp < len(L) and rp < len(R):
        if L[lp] < R[rp]:
            A[start_p] = L[lp]
            start_p += 1
            lp += 1
        else:
            A[start_p] = R[rp]
            start_p += 1
            rp += 1
    while lp < len(L):
        A[start_p] = L[lp]
        start_p += 1
        lp += 1
    while rp < len(R):
        A[start_p] = R[rp]
        start_p += 1
        rp += 1
    return

def合并排序（A、左、右）：
如果左+1>=右：
返回
中间=（左+右）//2
合并排序（A、左、中）
合并排序（A、中、右）
合并（A、左、中、右）
def合并（A、左、中、右）：
L=A[左：中]
R=A[中间：右侧]
lp=0
rp=0
开始p=左#！！
当lp

我没有通读所有的代码，但是引起注意的第一件事是在两个递归调用中都包含了

mid

。应该是

mergesort（A，左，中）

和

mergesort（A，中+1，右）

@mangusta，我认为这不是问题。代码将给

mergesort

的最后一个参数视为超出预期范围的索引，就像Python中的本机函数一样。我没有通读所有代码，但首先要注意的是，在两个递归调用中都包含了

mid

。应该是

mergesort（A，左，中）

和

mergesort（A，中+1，右）

@mangusta，我认为这不是问题。代码将给

mergesort

的最后一个参数视为超出预期范围的索引，这与Python中的本机函数非常相似。您能对此答案给出一些反馈吗？您能对此答案给出一些反馈吗？