Question

我必须将此递归算法转换为迭代算法：

  int alg(int A[], int x, int y, int k){
    int val = 0;

    if (x <= y){
      int z = (x+y)/2;

      if(A[z] == k){
        val = 1;
      }

      int a = alg(A,x,z-1,k);

      int b;

      if(a > val){
        b = alg(A,z+1,y,k);
      }else{
        b = a + val;
      }

      val += a + b;
  }

  return val;
 }

我尝试了while循环，但是我不知道如何计算“ a”和“ b”变量，所以我这样做了：

  int algIterative(int A[], int x, int y, int k){
   int val = 0;

   while(x <= y){
     int z = (x+y)/2;

     if(A[z] == k){
        val = 1;
     }

     y = z-1;
   }
  }

但是实际上我无法弄清楚该算法的作用。我的问题是：

此算法有什么作用？如何将其转换为迭代式？我需要使用堆栈吗？

任何帮助将不胜感激。

Answer 1

我不确定alg是否会计算出有用的东西。

它处理数组A在索引x和y之间的部分，并计算一种计数器。

如果间隔为空，则返回值（val）为0。否则，如果此子数组的中间元素等于k，则val设置为1。然后，将左右子数组的值相加，并将总数返回。因此，以某种方式，它可以计算数组中k的数量。

但是，如果发现左侧的计数不大于val，即val = 0时为0或val = 1时为0或val = 1时为1，则右侧的值将作为左侧+值。

不使用堆栈可能会进行反递归。如果查看所遍历的子间隔的序列，则可以从N的二进制表示形式对其进行重构。然后，该函数的结果就是沿后处理过程收集的部分结果的累加。

如果可以将后订单转换为有序订单，则将减少到A上的一次线性传递。这有点技术性。

Answer 2

借助二维数组，可以这样简单地实现以下目的：

int n = A.length;
int[][]dp = new int[n][n];
for(int i = n - 1;i >= 0; i--){
    for(int j = i; j < n; j++){
        // This part is almost similar to the recursive part.
        int z = (i+j)/2;
        int val = 0;
        if(A[z] == k){
          val = 1;
        }

        int a = z > i ?  dp[i][z - 1] : 0;

        int b;

        if(a > val){
           b = (z + 1 <= j) ? dp[z + 1][j] : 0;
        }else{
           b = a + val;
        }

        val += a + b;
        dp[i][j] = val; 
    }
}
return dp[0][n - 1];

说明：

请注意，对于i，它正在减少，而j，它正在增加，因此，在计算dp[x][y]时，您需要dp[x][z - 1] (with z - 1 < j)和dp[z + 1][j] (with z >= i) ，并且这些值应该已经填充。

从递归算法到迭代算法

2 个答案: