Question

这里是在merge merge中进行分区的代码。我无法理解recusrion究竟是如何工作的！

MERGE SORT PARTITION

void partition(int arr[], int low, int high){
    int mid;
    if(low < high){
         mid = (low + high)/2;
         partition(arr, low, mid);
         partition(arr, mid + 1, high);
         mergeSort(arr, low, mid, high);
    }
}

实际上我在许多递归问题中搞砸了，并且无法理解系统堆栈在递归中是如何工作的...... 我是初学者..

Answer 1

我会尝试让递归函数更简单。例如，一个阶乘伪代码的小例子：

int fact(n)
{
  if(n==1 || n==0) return 1;
  else
  return (n*fact(n-1));
}

这样做会创建一堆函数。假设我调用fact(3)这将形成如下堆栈：

fact(0)
fact(1)
fact(2)
fact(3)

其中每个函数都被推入堆栈。首先调用fact(3)。 fact(3)来电fact(2)。通过后 -

堆积积累：

                                               fact(0)
                                   fact(1)     fact(1)
                       fact(2)     fact(2)     fact(2)
empty --> fact(3) ---> fact(3) --> fact(3) --> fact(3)

现在该函数捕获n=0并返回1。现在函数开始弹出。

Stack：

   fact(0) -----> (returns 1) = 1
                    fact(1) -----> (returns 1) * 1 (1's popped out)
                                     fact(2) -----> (returns 2) * 1 (1 is actually 1*1)
                                                      fact(3) -----> (returns 3) * (2 = 2*1*1)
                                                                                          ----->6

编辑：功能添加了pop。至于排序堆栈，请查看@ P0W的答案。

尝试一个小例子并构建你的堆栈。然后转向复杂的。记住练习是关键。这就是递归函数作为堆栈的工作方式。

希望它有所帮助。：）

Answer 2

让我们举一个

的例子

数组arr ={ 5,2,4,7,1,3,2,6}; 8个元素

                            1 2 3 4 5 6 7
                                  ^(partition+mergeSort)
                                  |  
                    +------------+ +---------------+
                    |                              |
                2 4 5 7                          1 2 3 6
                    ^   (partition+mergeSort)        ^ (partition+mergeSort)  
                    |                              |
                +--+ +---+                     +--+ +---+
                |        |                     |        |
               2  5     4  7                 1   3     2  6
                     ^ (partition+mergeSort)          ^  (partition+mergeSort) 
                     |                              | 
                +---+ +---+                    +---+ +---+
                |         |                    |         |
              5   2     4   7                1  3      2   6 
                 4 elements                      4 elements 

                          Initial Unsorted Array

从下到上，用

形成两个数组

arr[low...mid]和 <{1}}在每次递归调用时，最后它们都会合并。

分区＆amp;只要arr[mid+1...high]＆lt;合并过程继续进行。 low

这只是high如何在这里工作的一个例子，你可以按照这个例子的代码。

对此未排序数组的mergeSort调用将具有：

第一次通过partition(arr, 0,7) mid =3使用

分为两部分

arr和partion(arr,0,3)

每个分区再次分成两部分，即0到3分为partion(arr,4,7)＆amp; (0,1)，再次(2,3)和(0,1)。 (1,1)跳过(1,1)，最后2个元素与low > high合并

一组这样的小排序数组最终会合并起来，因为它会在后续传递中递归。

这里有点难以解释，在文本格式中，在纸上试试，我相信你可以弄明白，用更小的数组，比如4个元素。

c堆栈中的递归

2 个答案: