如何使用堆栈将以下代码替换为非递归代码?

发布于 2024-12-10 01:14:40 字数 954 浏览 0 评论 0原文

这是一个有限状态机:

private int recursive(int rc, int pc, int sc) {
    for (;;) {
        Instruction actual = program[rc][pc];
        switch (actual.type) {
            case FIRST:
                if (sc >= input.length || input[sc] != actual.c1) return -1;
                pc++; sc++;
                continue;
            case SECOND:
                pc = actual.n1;
                continue;
            case THIRD:
                int result = recursive(rc, actual.n1, sc);
                if (result != -1) return result;
                pc = actual.n2;
                continue;
            case FOURTH:
                result = recursive(actual.n1, 0, sc);
                if (result == -1) return -1;
                pc++; sc = result;
                continue;
            case FIFTH:
                if (sc == input.length) return sc;
                return -1;
        }
        return -1;
    }
}

感谢您的帮助。

This is a finite-state machine:

private int recursive(int rc, int pc, int sc) {
    for (;;) {
        Instruction actual = program[rc][pc];
        switch (actual.type) {
            case FIRST:
                if (sc >= input.length || input[sc] != actual.c1) return -1;
                pc++; sc++;
                continue;
            case SECOND:
                pc = actual.n1;
                continue;
            case THIRD:
                int result = recursive(rc, actual.n1, sc);
                if (result != -1) return result;
                pc = actual.n2;
                continue;
            case FOURTH:
                result = recursive(actual.n1, 0, sc);
                if (result == -1) return -1;
                pc++; sc = result;
                continue;
            case FIFTH:
                if (sc == input.length) return sc;
                return -1;
        }
        return -1;
    }
}

Thanks for helping.

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(1

未蓝澄海的烟 2024-12-17 01:14:40

考虑一下递归。当您递归调用方法时,您实际上调用了方法并将同一方法的先前调用的状态存储在某处。你把这个状态存储在哪里?答案是“在堆栈中”。但是当您使用递归调用时,系统会为您管理堆栈。

所以,你必须自己管理它。这意味着以下内容。在第一次方法调用之前创建堆栈。更改方法的签名:它应该接受堆栈作为参数。堆栈应该包含您的状态。如果不检查代码,它可以是原始对象,也可以是复杂对象。如果您需要复杂的对象,请创建自己的类 State,它将保存所有需要的信息。

我希望这已经足够了。祝你好运!

Think about recursion. When you invoke method recursively you actually call method and store somewhere the state of previous invocations of the same method. Where are you storing this state? The answer is "in stack." But when you are using recursive invocation the system manages stack for you.

So, you have to mange it yourself. This means the following. Create stack before the first method invocation. Change the signature of the method: it should accept the stack as a parameter. The stack should contain your state. Without examining your code it can be either primitive or complex object. If you need complex object create your own class State, that will hold all needed information.

I hope this is enough. Good luck!

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文