Question

这个问题几次被问到，但我仍然觉得很难将易读且直观的代码转换成迭代代码。例如，我正在练习编码问题，我得到26个整数，表示每个字符出现在字符串中的次数。我应该打印所有可能的字符串。以下是我的递归代码

private static void combinatorial(String prefix, ArrayList<Integer> remainingToFill,
        int totalLength) {
    if (prefix.length() == totalLength) {
        System.out.println(prefix);
    }
    for (int i = 0; i < remainingToFill.size(); i++) {
        if (remainingToFill.get(i) > 0) {
            ArrayList<Integer> toFill = new ArrayList<>(remainingToFill);
            toFill.set(i, toFill.get(i) - 1);
            combinatorial(prefix + (char) ('a' + i), toFill, totalLength);
        }
    }
}

我编写了这个的迭代版本，但结果函数要复杂得多，而且不易阅读，我花了更多的时间对它进行编码。我该如何解决这类问题？我可以遵循哪些简单的技术，这将导致简单易读的代码？

Answer 1

嗯，编程语言支持程序递归表达的原因是它通常比显式迭代形式更简单。所以你的问题几乎是自我回答。

但是，确实是一种将递归表单转换为始终有效的迭代表单的有条理方法。使用goto语言是有帮助的，Java没有。

首先让我们清理java。我们想要使用最少数量的参数和局部变量，因为剩下的必须放在我们的显式堆栈上。开始了。我们取消了i和prefix之外的所有内容。

class CombinationLister {
  private final int[] counts;
  private final int length;

  CombinationLister(int[] counts) {
    this.counts = counts.clone();
    this.length = Arrays.stream(counts).sum();
  }

  private void list(String prefix) {
    if (prefix.length() == length) {
      System.out.println(prefix);
    }
    for (int i = 0; i < counts.length; i++) {
      if (counts[i] > 0) {
        --counts[i];
        list(prefix + (char) ('a' + i));
        ++counts[i];
      }
    }
  }

  void run() {
    list("");
  }
}

现在让我们转录到C，其中goto。通过添加全局字符串缓冲区，即使prefix也很容易消除。

#include <stdio.h>

char str[100];
int counts[] = { 1, 2, 3 };
int n_counts = 3;
int total_count = 6;
int len = 0;

void list(void) {
  if (len == total_count) printf("%.*s\n", total_count, str);
  for (int i = 0; i < n_counts; i++) {
    if (counts[i] > 0) {
      str[len] = 'a' + i;
      --counts[i];
      ++len;
      list();
      --len;
      ++counts[i];
    }
  }
}

现在，规则是：

为每个局部变量和参数构建一个包含一个字段的记录堆栈。这里我们只剩i，所以我们甚至不需要记录。一堆int即可。
用。替换递归调用站点
- a push到堆栈上，然后
- 将参数重置为新值（此处我们没有），然后
- 跳转到函数的开头，
- 跳转后立即贴上标签rtn:。
在函数结束时，添加一个检查堆栈是否为空的epilog。如果没有，它会弹出堆栈并跳转到rtn:。

这些规则基本上模仿了编译器为处理递归调用而生成的代码。

总而言之，我们有：

int stk[100];
int p = 0; // stack pointer

void list(void) {
  int i;
 start:
  if (len == total_count) printf("%.*s\n", total_count, str);
  for (i = 0; i < n_counts; i++) {
    if (counts[i] > 0) {
      str[len] = 'a' + i;
      --counts[i];
      ++len;
      stk[p++] = i;  // push i on stack
      goto start;
     rtn:
      --len;
      ++counts[i];
    }
  }
  // epilog
  if (p > 0) {
    i = stk[--p];  // restore i from stack
    goto rtn;
  }
}

如果您仔细按照步骤操作，则每次都会先运行代码。唯一的补充提示是，当有多个递归调用网站时，您需要为每个rtn1:，rtn2:等添加一个返回标签，并且需要额外的int字段在表示返回站点的堆栈中，在epilog中使用switch语句跳转到正确的。

当然这不是很好的代码。我们想要摆脱goto。事实证明，通过做＆＃34;代数＆＃34;将gotos转换为循环。有几十种转换技术......这里描述的太多了。这很像简化数学课上的方程式。有时需要添加布尔标志。但在这种情况下，我们并不需要。我说完了：

void list(void) {
  for (int i = 0;;) {
    while (i < n_counts && counts[i] == 0) i++;
    if (i < n_counts) {
      --counts[i];
      str[len] = 'a' + i;
      stk[p++] = i;
      if (++len == total_count) printf("%.*s\n", total_count, str);
      i = 0;
    } else if (p > 0) {
      i = stk[--p];
      --len;
      ++counts[i++];
    }
    else break;
  }
}

只是为了好玩，回到Java：

class CombinationLister {
  private final int[] counts;
  private final char[] str;
  private final int[] stk;
  private int p = 0;
  private int len = 0;

  CombinationLister(int[] counts) {
    this.counts = counts.clone();
    this.str = new char[Arrays.stream(counts).sum()];
    this.stk = new int[str.length];
  }

  void run() {
    for (int i = 0;;) {
      while (i < counts.length && counts[i] == 0) i++;
      if (i < counts.length) {
        --counts[i];
        str[len] = (char) ('a' + i);
        stk[p++] = i;
        if (++len == str.length) System.out.println(str);
        i = 0;
      } else if (p > 0) {
        i = stk[--p];
        --len;
        ++counts[i++];
      } else break;
    }
  }
}

Answer 2

public static void combinatorial(ArrayList<Integer> remainingToFill, int totalLength) {
    Stack st = new Stack();
    st.push( new Pair<String,Integer>("", 0) );
    while( !st.empty() ){
        Pair<String,Integer> top = (Pair<String,Integer>) st.pop();
        String prefix = top.getKey();
        Integer i = top.getValue();
        if (prefix.length() == totalLength) {
            System.out.println(prefix);
            int index= prefix.charAt(prefix.length()-1 )-'a' ;
            remainingToFill.set( index , remainingToFill.get(index) + 1 );
        }
        else{
            if( i== remainingToFill.size() ){
                if( prefix.length()>0 ){
                    int index= prefix.charAt(prefix.length()-1 )-'a' ;
                    remainingToFill.set( index , remainingToFill.get(index) + 1 );
                }
            }
            else{
                st.push( new Pair<String,Integer>(prefix, i+1) );
                if( remainingToFill.get(i) > 0 ){
                    remainingToFill.set(i, remainingToFill.get(i) - 1);
                    st.push( new Pair<String,Integer>(prefix+(char)('a'+i), 0) );
                }
            }
        }
    }
}

如何将递归转换为迭代？

2 个答案: