Algorithm 通过对合并排序的递归调用使用控制流理解递归

我正在研究在合并排序中使用递归的控制流

我使用的特定算法是：

MergeS(ar, p, r){

 1. if p<r{
 2.    k = floor[(p+r)/2]
 3.    MergeS(ar, p , k)
 4.    MergeS(ar, k+1, r) //in the schematic diagram I have written this as mergeS(,,)
 5.    Merge(ar, p ,k, r)
 6. } 
 7.}

Merge(ar, p, k, r){

 8.  n1 = k-p+1
 9.  n2 = r-p
 10. let L[1...n1+1] and R[1....n2+1] be new arrays

 11. for i=1 to n1
 12.   L[i] = ar[p+i-1]

 13. for j=1 to n2
 14.   R[j] = ar[k+j]

 15. L[n1+1] = Infinity
 16. R[n2+1] = Infinity

 17. i = 1
 18. j = 1

 19. for t = p to r
 20.   if L[i] <= R[j]
 21.     A[t] = L[i]
 22.     i = i+1
 23.   else
 24.     A[t] = R[j]
 25.     j = j+1
 30. }

---暂停1:合并（ar，0，5）----调用-->2:合并（ar，0，2）---------

if（03:合并（ar，0，1）---------

if（04:合并（ar，0，0）---------

if（05:合并（ar，0+1，5）---------

if（16:合并（ar，1，3）---------

if（17:合并（ar，1，2）---------

if（18:合并（ar，1，1）---------

if（19:合并（ar，1+1，5）---------

if（210:合并（ar，2，3）---------

if（211:合并（ar，2，2）----------

if（212:合并（ar，2+1，5）----------

if（313:合并（ar，5，5）---------

if（5合并（ar，3，4，5）----------

n1=4-3+1=2
n2=5-4=1
对于（i=0到i=1）：
迭代1：
L[0]=ar[3+0-1]=ar[2]//值56分配给ar[2]
迭代2：
L[1]=ar[3+1-1]=ar[3]//值12分配给ar[3]
对于（j=0到j=0）：
迭代1：
R[0]=ar[4+0]=ar[4]//值4分配给ar[4]
x=0；
y=0；
对于（t=0到t=1）：
迭代1：
/*如果（L[0]问题中的算法中的索引需要在代码中修改以便于使用。我不是说算法是错误的，它是绝对正确的，只需要修改

合并的调整代码
：

 private static void Merge(int[] ar, int p, int k, int r) {

    int n1 = k-p+1;
    int n2 = r-k;
    int[] L = new int[n1+1];
    int[] R = new int[n2+1];

    for(int i=0; i<n1; i++){
        L[i] = ar[p+i]; // p+i and not p+i-1
    }
    for(int i=0; i<n2; i++){ 
        R[i] = ar[k+i+1]; //k+1+i and not k+i
    }

    // Use of Tnteger.MAX_VALUE
    L[n1]=Integer.MAX_VALUE;
    R[n2]=Integer.MAX_VALUE;

    int i = 0;
    int j = 0;

    for(int t=p; t<=r; t++){ //carefully set initialization and t<=r and not simply t<r
        if(L[i]<r[j]){
            ar[t] = L[i];
            i++;
        }
        else{

              ar[t] = R[j];
              j++;
            }
        }
    }
}

私有静态无效合并（int[]ar，int p，int k，int r）{
int n1=k-p+1；
int n2=r-k；
int[]L=新的int[n1+1]；
int[]R=新的int[n2+1]；
对于（int i=0；显示的递归调用流显示从0开始的索引，但psuedo代码显示从1开始的索引。使用p=开始索引和r=结束索引（数组最后一个元素后的1）可能更简单。两个合并递归调用将是合并（ar，p，k）和合并（ar，k，r）…（k而不是k+1）。如果我采用合并（ar、k、r），则中间索引元素将不必要地被复制多次（当调用分区的右侧部分时）在每个递归调用中。如果您可以检查我在每个调用中传递的参数并验证它们是否正确？如果不正确，我在哪个调用中输入了错误的参数。假设r是合并中的结束索引（ar，p，r），那么整个数组的基于C的循环将是for（I=0；Iif(0<2):true ; set k=(0+2)/2

if(0<1):true ; set k=(0+1)/2

if(0<0):false  

if(1<5):true ; set k=(1+5)/2

if(1<3):true ; set k=(1+3)/2

if(1<2):true ; set k=(1+2)/2

if(1<1):false

if(2<5):true ; set k=(2+5)/2

if(2<3):true ; set k=(2+3)/2

if(2<2):false 

if(3<5):true ; set k=(3+5)/2

if(5<5):false 

n1 = 4-3+1=2
n2 = 5-4=1

for(i = 0 to i=1):
  iteration1: 
    L[0] = ar[3+0-1]= ar[2] //value 56 is assigned to ar[2]
  iteration2:
    L[1] = ar[3+1-1] = ar[3] //value 12 is assigned to ar[3]

for(j=0 to j=0):
  iteration1:
    R[0] = ar[4+0] = ar[4] //value 4 is assigned to ar[4]

x = 0;
y = 0;

for(t=0 to t=1):
  iteration1: 
   /* if(L[0]<= R[0]) //56<=4:false */
   else
     ar[0] = R[0] //4 is assigned to ar[0]
     y = y+1
  iteration2:
   if(L[0]<=R[1]): //56<=infinity
     ar[1] = L[0] // 56 is assigned to ar[1]

 private static void Merge(int[] ar, int p, int k, int r) {

    int n1 = k-p+1;
    int n2 = r-k;
    int[] L = new int[n1+1];
    int[] R = new int[n2+1];

    for(int i=0; i<n1; i++){
        L[i] = ar[p+i]; // p+i and not p+i-1
    }
    for(int i=0; i<n2; i++){ 
        R[i] = ar[k+i+1]; //k+1+i and not k+i
    }

    // Use of Tnteger.MAX_VALUE
    L[n1]=Integer.MAX_VALUE;
    R[n2]=Integer.MAX_VALUE;

    int i = 0;
    int j = 0;

    for(int t=p; t<=r; t++){ //carefully set initialization and t<=r and not simply t<r
        if(L[i]<r[j]){
            ar[t] = L[i];
            i++;
        }
        else{

              ar[t] = R[j];
              j++;
            }
        }
    }
}

if(0<5):true ; set k=(0+5)/2

if(0<2):true ; set k=(0+2)/2

if(0<1):true ; set k=(0+1)/2

if(0<0):false  

if(1<_1_):_false_ ;