n层循环嵌套的非递归实现

Question

想用一个n层的嵌套模拟近位，如000，001，002……010，011，012……xxx，如果用传统递归实现的话当层数多（如10层以上）经常无法实现，有没有非递归的实现，比如用一个堆栈模拟层数，思路不是很清晰，请各位指教，请给出伪代码或python代码实现，谢谢。

Answer 1

不清楚“无法实现”是一个什么意思，你说列举的嵌套、栈等概念最好用的不就是递归吗。

Answer 2

我用Java写了段小程序，不知道题主是不是想试这种情况，仓促写就，也请批评指正。

import java.util.Stack;

public class BinaryAddition {
    private static Stack<Integer> additionStack = new Stack<>();

    public static int[] positiveBinaryAdd(int[] a, int[] b) {
        int bit = 0;
        int i = a.length - 1;
        int j = b.length - 1;
        for (; 0 <= i && 0 <= j; --i, --j) {
            if ((0 > a[i]) || (1 < a[i]) || (0 > b[j]) || (1 < b[j])) {
                return null;
            }
            int tmp = a[i] + b[j] + bit;
            additionStack.push(Integer.valueOf(tmp % 2));
            bit = 1 < tmp ? 1 : 0;
        }
        if (i == j) {
            if (1 == bit) {
                additionStack.push(Integer.valueOf(bit));
            }
        } else {
            int[] m = i > j ? a : b;
            int index = Math.max(i, j);
            if (0 == bit) {
                for (i = index; 0 <= i; --i) {
                    additionStack.push(Integer.valueOf(m[i]));
                }
            } else {
                for (i = index; 0 <= i; --i) {
                    if (1 < m[i] + bit) {
                        additionStack.push(Integer.valueOf(0));
                        bit = 1;
                    } else {
                        additionStack.push(Integer.valueOf(m[i] + bit));
                        bit = 0;
                    }
                }
            }
        }
        if (1 == bit) {
            additionStack.push(Integer.valueOf(bit));
        }
        int[] result = new int[additionStack.size()];
        for (i = 0; i < result.length; ++i) {
            result[i] = additionStack.pop().intValue();
        }
        return result;
    }
}