我写了这个算法，但我真的不知道是否可以将其转换为迭代算法。我试图得到立方体形状中每个节点的邻接节点。相邻节点必须满足两个条件：
- 这是一个灰色节点
- 它在
distance的半径范围内
def find_continumm(seed, node, row, gray, xyz, distance):
"""
seed: the nodes we want to find the adjacent nodes for.
node: the candidate nodes to be in the adjacency.
row: save the nodes that are adjacent.
gray: boolean array that tells if a node is a gray or not.
xyz: the 3 dim of the shape.
distance: the radius
"""
node_ravel = np.ravel_multi_index(node, xyz)
if node_ravel in row or ~gray[node_ravel] or math.dist(node, seed) > distance:
return
row.add(node_ravel)
if node[0] < xyz[0]:
node[0] = node[0] + 1
find_continumm(seed, node, row, gray, xyz, distance)
node[0] = node[0] - 1
if node[0] > 0:
node[0] = node[0] - 1
find_continumm(seed, node, row, gray, xyz, distance)
node[0] = node[0] + 1
if node[1] < xyz[1]:
node[1] = node[1] + 1
find_continumm(seed, node, row, gray, xyz, distance)
node[1] = node[1] - 1
if node[1] > 0:
node[1] = node[1] - 1
find_continumm(seed, node, row, gray, xyz, distance)
node[1] = node[1] + 1
if node[2] < xyz[2]:
node[2] = node[2] + 1
find_continumm(seed, node, row, gray, xyz, distance)
node[2] = node[2] - 1
if node[2] > 0:
node[2] = node[2] - 1
find_continumm(seed, node, row, gray, xyz, distance)
node[2] = node[2] + 1
是的，总是可以将递归算法转化为迭代算法。执行此操作的一般过程是切换到延续传递样式，应用去函数化，然后应用尾部调用消除。这三个转换的组合将把递归函数变成迭代函数，可能需要堆栈。
在我将此应用于您的代码之前，我将简要地重写您的代码如下：
def find_continumm(seed, node, row, gray, xyz, distance):
def helper():
node_ravel = np.ravel_multi_index(node, xyz)
if node_ravel in row or ~gray[node_ravel] or math.dist(node, seed) > distance:
return
row.add(node_ravel)
for i in range(3):
if node[i] < xyz[i]:
node[i] += 1
helper()
node[i] -= 1
if node[i] > 0:
node[i] -= 1
helper()
node[i] += 1
helper()
您可以亲眼看到，这相当于您的代码版本。我将做最后一次重写，使用while-循环而不是for-循环：
def find_continumm(seed, node, row, gray, xyz, distance):
def helper():
node_ravel = np.ravel_multi_index(node, xyz)
if node_ravel in row or ~gray[node_ravel] or math.dist(node, seed) > distance:
return
row.add(node_ravel)
i = 0
while i < 3:
if node[i] < xyz[i]:
node[i] += 1
helper()
node[i] -= 1
if node[i] > 0:
node[i] -= 1
helper()
node[i] += 1
i += 1
helper()
这大大简化了代码，并使其成为迭代版本变得更加简单。
得到的迭代版本是：
beginning = 0
entering_loop = 1
finishing_first_call = 2
enter_second_if = 3
finishing_second_call = 4
increment_i = 5
# the actual values of the above variables don't matter
# so long as they're different
def find_continumm(seed, node, row, gray, xyz, distance):
stack = []
add_to_stack = lambda tag, data : stack.append((tag, data))
back_to_beginning = lambda : add_to_stack(beginning, None)
back_to_beginning()
while stack:
tag, i = stack.pop()
if tag is beginning:
node_ravel = np.ravel_multi_index(node, xyz)
if node_ravel in row or ~gray[node_ravel] or math.dist(node, seed) > distance:
pass
else:
row.add(node_ravel)
add_to_stack(entering_loop, 0)
elif tag is entering_loop:
if i < 3:
if node[i] < xyz[i]:
node[i] += 1
add_to_stack(finishing_first_call, i)
back_to_beginning()
else:
add_to_stack(enter_second_if, i)
elif tag is finishing_first_call:
node[i] -= 1
add_to_stack(enter_second_if, i)
elif tag is enter_second_if:
if node[i] > 0:
node[i] += 1
add_to_stack(finishing_second_call, i)
back_to_beginning()
else:
add_to_stack(increment_i, i)
elif tag is finishing_second_call:
node[i] -= 1
add_to_stack(increment_i, i)
elif tag is increment_i:
add_to_stack(entering_loop, i + 1)
如果你看一下迭代版本，你会发现它与带有while循环的递归版本非常相似。每个标签对应于这个递归版本中的特定代码行；跳回"；。