Question

假设我有两个数组。

a = ["A1", "A2", "B1"]
b = ["C2", "B1", "C1"]

我想要的是首先遍历数组'a'，

从数组'a'中获取元素并对其进行一些操作。

1.a如果该操作成功，则移至数组'a'的下一个元素。

1.b如果该操作不成功，则开始迭代数组'b'。
从数组'b'获取元素并对其进行一些操作。

2.a如果该操作成功，则移至数组'b'的下一个元素。

2.b如果该操作不成功，则从我们在1.a中离开的位置开始迭代数组'a'，依此类推......

所有这一切都将继续，直到两个数组中的所有元素都被遍历。我应该用什么方法来编码？如果需要更多细节，我很乐意写。

Answer 1

这与合并排序/合并两个排序数组中的合并过程非常相似。如果你还没有，也要考虑一下。只需维护一个标志变量即可知道下一个要处理的数组。

iterA := 0
iterB := 0
flag := 0

while (iterA < size(A) && iterB < size(B)):

    if (flag == 0):

        if(doOperation(A[iterA]) == success):
            iterA := iterA + 1
        else:
            flag := 1
            iterA := iterA + 1

    if (flag == 1):

        if(doOperation(B[iterB]) == success):
            iterA := iterA + 1
        else:
            flag := 0
            iterA := iterA + 1

while (iterA < size(A)):
    doOperation(A[iterA])
    iterA := iterA + 1

while (iterB < size(B)):
    doOperation(B[iterB])
    iterB := iterB + 1

我假设如果数组的所有元素都成功运行，我们只对另一个数组的其余元素进行操作。

Answer 2

这是一个非常简单的想法。你想要的是：

until both lists A and B exhausted
   while not (A exhausted or processing A has failed)
      process next element of A
   while not (B exhausted or processing B has failed)
      process next element of B

现在你可以翻译大多数正常的迭代语言了。在C中，

for (int ia = 0, ib = 0; ia < a_len || ib < b_len; ) {
  while (ia < a_len) if (process(a[ia++]) == FAIL) break;
  while (ib < b_len) if (process(b[ib++]) == FAIL) break;
}

但是不同的语言提供了其他表达方式。这里一个很好的例子是co-routines。

coroutine processA
  while A not empty and process(nextElement(A)) != FAIL, /* empty */ ;
  if not empty(B) yield B

coroutine processB
  while B not empty and process(nextElement(B)) != FAIL, /* empty */ ;
  if not empty(A) yield A

精美对称，没有？

根据元素的操作迭代数组

2 个答案: