Algorithm 将其从递归更改为迭代

一些伪代码：

 func F(int x. int y, array p){
       p[x] = 1;
       if (x<=y){
          for each item in getItems(x,p){
              p = F(item,y,p);
          }
       }
       return p;
    }

func F（整数x.整数y，数组p）{
p[x]=1；
如果（x您可以通过添加防止重复处理
x
值的保护来保持递归版本（没有堆栈溢出）

func F(int x. int y, array p){
   if(p[x] != 1) {
       p[x] = 1;
       if (x<=y){
           for each item in getItems(x,p){
               p = F(item,y,p);
          }
       }
   }
   return p;
}

i、 e.指定一个您知道在初始数组中没有使用的值。然后当函数完成其处理时，遍历数组并将所有空值设置为1。
您可以通过添加防止重复处理
x
值的保护来保持递归版本（没有堆栈溢出）

func F(int x. int y, array p){
   if(p[x] != 1) {
       p[x] = 1;
       if (x<=y){
           for each item in getItems(x,p){
               p = F(item,y,p);
          }
       }
   }
   return p;
}

i、 e.分配一个您知道在初始数组中未使用的值。然后，当函数完成其处理时，遍历数组并将所有空值设置为1。
您可以通过模拟调用堆栈来完成此操作：

struct stackentry {
    int x;
    Item item; // see exercise for reader, below
};

func F(int x, int y, array p){
   dynamic_list_of_stackentry mystack;
  start:
   p[x] = 1;
   if (x<=y){
      for each item in getItems(x,p){
          mystack.push(stackentry(x, item));
          x = item
          goto start
        resume:
          x = mystack.top().x;
          item = mystack.top().item;
          mystack.pop();
      }
   }
   if mystack.size() > 0:
      goto resume
   return p;
}

您可以通过模拟调用堆栈来实现这一点：

struct stackentry {
    int x;
    Item item; // see exercise for reader, below
};

func F(int x, int y, array p){
   dynamic_list_of_stackentry mystack;
  start:
   p[x] = 1;
   if (x<=y){
      for each item in getItems(x,p){
          mystack.push(stackentry(x, item));
          x = item
          goto start
        resume:
          x = mystack.top().x;
          item = mystack.top().item;
          mystack.pop();
      }
   }
   if mystack.size() > 0:
      goto resume
   return p;
}

实际上，您的程序将进入无限循环（如果使用递归或迭代，则无所谓）。首先计算逻辑。它不会进入无限循环。它适用于较小的边界。问题是边界太大时。请显示
getItems
的简化版本。它如何依赖于
p
？一个愚蠢的问题：是否按值传递并返回数组？这不重要；它只返回x以下的几个数字x以上的一些数字是基于p的哪些元素已经被标记的（这与素数有关，所以如果这就是你提问的原因，这里没有很好的模式。这不是一个简单的干净函数，但重写F不需要它）nm：不，根据参考，这是你的程序将进入无限循环（使用递归或迭代并不重要）。首先计算逻辑。它不会进入无限循环。它适用于较小的边界。问题是边界太大时。请显示
getItems
的简化版本。它如何依赖于
p
？一个愚蠢的问题：是否按值传递并返回数组？这不重要；它只返回x以下的几个数字x以上的一些数字是基于p的哪些元素已经被标记的（这与素数有关，所以如果这就是你提问的原因，这里没有好的模式。这不是一个简单的干净函数，但重写F不需要它）nm：不，通过引用