Question

在不同的网站上，伪代码与下面的代码类似：

merge_sort(num_list)
length <-- length of num_list

if length > 1

    shorter_list_A <-- first half of num_list
    shorter_list_B <-- second half of num_list

    result_A <-- merge_sort(shorter_list_A)
    result_B <-- merge_sort(shorter_list_B)

    sorted_list <-- merge(result_A, result_B)

    return sorted_list
else
    return num_list
end

所以如果我们有4个数字：8,3,6,2

MergeSort(8,3,6,2)

前半部分数字被放入Shorter_list_A（8,3）下半部分的数字输入Shorter_list_B（6,2）

    shorter_list_A <-- first half of num_list
    shorter_list_B <-- second half of num_list

所以我们现在有两个列表：short_list_A（8,3）和Shorter_list_B（6,2）

    result_A <-- merge_sort(shorter_list_A)

Merge_sort再次调用merge_sort，所以会发生这样的事情：

merge_sort(Shorter_list_A)  // also 8,3
length <-- length of Shorter_list_A

if length > 1

    shorter_list_A <-- first half of Shorter_list_A 
//8 put to Shorter_list_A
    shorter_list_B <-- second half of Shorter_list_A
//3 put to Shorter_list_B

    result_A <-- merge_sort(shorter_list_A)
//merge_sort calls merge_sort again
    result_B <-- merge_sort(shorter_list_B)

    sorted_list <-- merge(result_A, result_B)

    return sorted_list
else
    return Shorter_list_A
end

所以我们现在再次有两个列表：short_list_A（8）和Shorter_list_B（6）

从目前为止的解释来看，我是否理解正确或完全错误？

然后再次调用merge_sort。由于Shorter_list_A的长度仅为1，因此它只包含一个8的数字。这会发生什么：

merge_sort(Shorter_list_A)
length <-- length of Shorter_list_A
    return Shorter_list_A
end

返回Shorter_list_A，即8.

这里有什么回报？我被困在那里。

Answer 1

每次返回都会向调用者发回一个排序列表，其中列出了作为输入接收的元素。

在最底层，当只有一个元素时，默认情况下会对列表进行排序并返回。当您在result_A和result_B中分别获得一个元素的两个排序列表时，将它们都传递给merge()方法，此方法现在可以完成繁重的工作。这将获取两个列表并合并它们以提供一个新列表，其中包含按排序顺序排列的两个列表的元素。

Merge()的外观如何？

Merge()将实例化一个新列表。我们将其称为sorted_list，然后它将从它作为输入获得的两个列表的head开始读取，并将head位置的两个元素中的最小值放入并放置它刚刚创建的sorted_list。该方法将继续使用两个输入列表的head，直到它们都完成为止。现在，两个列表的合并按排序顺序显示在sorted_list中。我以为你希望列表从最小到最大排序。

浏览您的示例

在最后一级，使用单个元素，第一个head -> 8 -> null列表和第二个head -> 3 -> null列表将合并为head -> 3 -> 8 -> null

在此级别本身，它会将head -> 6 -> null和head -> 2 -> null的两个列表合并到head -> 2 -> 6 -> null

让底层被称为0.在0级，你只有单个元素。在级别1，您将拥有两个元素的列表。在级别2，您将有两个合并的2个元素的列表，以提供单个列表。

因此，从head -> 3 -> 8 -> null和head -> 2 -> 6 -> null开始，您将获得head -> 2 -> 3 -> 6 -> 8 -> null。

最后将返回此列表。没有进一步的水平。这是您获得原始未排序输入列表的级别，因此在此返回时，您将有效地将已排序列表返回给调用者。

总结

Level num_list Shorter_List_A Shorter_List_B Result_A Result_B sorted_list

2     8,3,6,2  8,3            6,2            3,8      2,6      2,3,6,8

1(a)  8,3      8              3              8        3        3,8  
1(b)  6,2      6              2              6        2        2,6

0(a)  8        -              -              -        -        8
0(b)  3        -              -              -        -        3 
0(c)  6        -              -              -        -        6
0(d)  2        -              -              -        -        2

所以，我们从第2级开始。在1（a），1（b）级递归地调用自己。然后从级别1再次在级别0（a），0（b），0（c），0（d）处自我调用，然后将合并的结果再次冒泡到级别2，然后返回排序列表。

Answer 2

你必须记住，它会向short_list_A递归，直到它从递归调用返回时获得条件client_id，它返回到调用堆栈中的上一个调用，如下所示：

https://api.instagram.com/v1/users/{user-id}/follows/?client_id={client_id}

所以它对length <= 1做同样的事情然后在返回调用堆栈之前合并结果。

所以举一个小例子，缩进显示递归深度：

result_A <-- merge_sort(shorter_list_A) 
// *** return here ***
result_B <-- merge_sort(shorter_list_B)
sorted_list <-- merge(result_A, result_B)
return sorted_list

希望这有帮助。

这是解释MergeSort伪代码的正确方法吗？这里有什么回报？

2 个答案: