Question

我最近开始学习计算机科学和Java编码，并遇到了遍历技术。我正在使用Stack编写Java代码。我一直遇到这个问题，找不到任何解决方案。无论如何，我们可以仅使用一个堆栈（没有任何额外的数据结构或额外的空间）来实现Post Order遍历吗？

我已经尝试过了，这是我的代码。

class node {
int data;
node left, right;
node(int val){
    data = val;
    left = right = null;
}
}
 public class binaryt {

public static void postorder(node root) {
    node current = root;
    Stack<node> st = new Stack<>();
    System.out.println();
    System.out.print("Post-order : ");  
    while(current!=null) {
        st.push(current);
        current = current.left;
    }
    while(!st.empty()) {
        current = st.pop();
        if(current.right==null) {
            System.out.print(current.data+" ");
            current = null;
        }
        else {
            st.push(current);
            current = current.right;
            while(current!=null) {
                st.push(current);
                current = current.left;
            }
        }
    }
}
public static void main(String[] args) {
    node root=null;


    root = new node(12);
    root.left = new node(8);
    root.left.left = new node(2);
    root.left.right = new node(9);
    root.right= new node(16);
    root.right.left= new node(13);
    root.right.right= new node(18);

    postorder(root);
}

}

由于无限循环中的代码，我无法找到问题所在。如果有人可以帮助我，那将是极大的青睐。非常感谢。

Answer 1

学习这些烦人的算法的最好方法是受苦并找到自己的解决方案，该解决方案会牢牢抓住您的大脑-因此您在做正确的事情。这对我来说总是很难。

做
- while（root！= null）
  - 如果不为null，则将root.right推入堆栈
  - 推根
  - root = root。左可堆叠
- root = stack.pop（）
- 如果（root.right == stack.peek）
  - stack.pop（）
  - 将根推入堆栈
  - root = root.right
- 其他
  - 打印根目录
  - root = null;
同时堆叠！空

您的问题

因此，您尝试进行的尝试中可能存在一些一般性错误。但是，这是我首先要解决的问题，然后我认为您将可以得到其他解决方案：

您不能只是从整个树上往下走。仅在检查了正确的节点并将其添加到堆栈后，才需要向左走。记住，递归实现将已经具有根/当前框架，然后它将调用左右树。因此，这意味着当前帧在左右调用完成之后排在最后。因此，函数调用堆栈在逻辑上保留左子树，右子树和当前帧。

Answer 2

这就是您的代码中正在发生的事情：

首先，您要在堆栈
然后没有 2 的左孩子，所以您来到while
现在弹出 2 ，它没有合适的子级，因此现在堆栈8,12中有两个值
接下来出现的是 8 ，它有一个合适的孩子，您将 8 再次推入堆栈。
现在您将 9 作为当前版本并将其推入堆栈。
现在您正在检查 9 的左侧，该值为空。
所以您再次从while(!st.empty()) {循环开始，该循环包含元素9，8,12
再次重复同样的事情，而while循环永远不会结束

您还可以在控制台上看到：后置订单：2 9 9 9 9 .....继续

这就是问题所在。

下面是一个解决方案：

public static void postorderIter( node root) {
    if( root == null ) return;

    Stack<node> s = new Stack<node>( );
    node current = root;

    while( true ) {

        if( current != null ) {
            if( current.right != null ) 
                s.push( current.right );
            s.push( current );
            current = current.left;
            continue;
        }

        if( s.isEmpty( ) ) 
            return;
        current = s.pop( );

        if( current.right != null && ! s.isEmpty( ) && current.right == s.peek( ) ) {
            s.pop( );
            s.push( current );
            current = current.right;
        } else {
            System.out.print( current.data + " " );
            current = null;
        }
    }
}

Answer 3

这是一个依赖于递归使其更具可读性的示例。

public static void postorder(node root) {
    Stack<node> nodes = new Stack<>();
    node curr = root;

    postOrderRecursive(curr, nodes);

    int size = nodes.size();
    while(size > 0){

        System.out.println(nodes.elementAt(0).data);
        nodes.remove(0);
        size = nodes.size();
    }
}
private static void postOrderRecursive(node n, Stack<node> nodes){
    if(n.left != null)
        postOrderRecursive(n.left, nodes);
    if(n.right != null)
        postOrderRecursive(n.right, nodes);

    nodes.push(n);
}

根据您的初始化输出： 2 9 8 13 18岁 16 12

没有访问数组的迭代后继遍历

3 个答案: