Java 修正我的“执行”；“有序树遍历”；带堆栈的算法

部分原因是我必须实现一个二叉树按序遍历的非递归方法。我有点卡住了。以下是我到目前为止的情况：

public void inorder(BinaryTree v) {
    Stack<BinaryTree> stack = new Stack<BinaryTree>();
    stack.push(v);
    System.out.println(v.getValue());

    while(!stack.isEmpty()) {
        while(v.getLeft() != null) {
            v = v.getLeft();
            stack.push(v);
            System.out.println(v.getValue());
        }

        while(v.getRight() != null) {
            v = v.getRight();
            stack.push(v);
            System.out.println(v.getValue());
        }
                stack.pop();
    }
}

---

给出

adhj

在代码之后，

getLeft（）

部分的while循环一直沿着树的左侧，然后退出

v

现在是节点

J

，它没有正确的子节点，因此下一个while循环不会运行

请尝试以下代码示例：

答:

//按顺序遍历：
//将节点保留在等待访问的路径中
堆栈s=新堆栈（）；
//要访问的第一个节点是最左侧的节点
节点=根；
while（节点！=null）{
s、 推送（节点）；
node=node.left；
}
//横穿这棵树
而（s.size（）>0）{
//访问顶部节点
node=（node）s.pop（）；
System.out.println（（String）node.data）；
//查找下一个节点
if（node.right！=null）{
node=node.right；
//要访问的下一个节点是最左侧的节点
while（节点！=null）{
s、 推送（节点）；
node=node.left；
}
}
}

您可以通过一个while循环大大简化上述操作：

Stack<Node> stack = new Stack<>();
Node current = root;
while(current != null || !stack.isEmpty()){
  if(current != null){
    stack.push(current);
    current = current.left;
  } else if(!stack.isEmpty()) {
    current = stack.pop();
    process(current);
    current = current.right;
  }
}

Stack Stack=新堆栈（）；
节点电流=根；
while（当前！=null | |！stack.isEmpty（））{
如果（当前！=null）{
堆栈推送（当前）；
current=current.left；
}如果（！stack.isEmpty（））{
当前=stack.pop（）；
过程（当前）；
current=current.right；
}
}

---

基本上，上面的代码推动堆栈上的左分支，直到到达分支中最左边的节点。然后它弹出并处理它（您可以打印它或用它做其他事情），然后它推动堆栈上的右分支进行处理，因为左分支和节点本身都完成了。

另一个更简单的二进制遍历实现：

import java.util.Stack;

public class BinaryTree {

    public static void main(String args[])
    {
        Node root = Node.createDummyTree();
        Node tnode; //= root;

        Stack<Node> stack = new Stack<Node>();

        if (root != null)
        {
            stack.push(root);
        }

        while (!stack.isEmpty())
        {
            tnode = stack.pop();

            if (tnode != null)
            {
                System.out.println(tnode.value);

                if(tnode.rightNode != null)
                {
                    stack.push(tnode.rightNode);
                }

                if (tnode.leftNode != null)
                {
                    stack.push(tnode.leftNode);
                }
            }
        }
    }

}

class Node {
    public Node leftNode;
    public Node rightNode;
    public String value;

    Node(String value)
    {
        this.value = value;
    }

    /**
     *  Construct a dummy binary Tree
     *               A
     *          /         \
     *         B           C
     *       /   \       /   \
     *      D     E     F     G
     *     / \   / \   / \   / \
     *    H   I J   K  L  M  N  O

     * @return
     */

    public static Node createDummyTree(){

        Node root = new Node("A");
        root.leftNode = new Node("B");
        root.rightNode = new Node("C");

        Node tnode = root.leftNode;
        tnode.leftNode = new Node("D");
        tnode.rightNode = new Node("E");

        Node tempNode = tnode.rightNode;  //remember "E"  

        tnode = tnode.leftNode;
        tnode.leftNode = new Node ("H");
        tnode.rightNode = new Node ("I");

        tnode = tempNode;

        tnode.leftNode = new Node ("J");
        tnode.rightNode = new Node ("K");

        tnode = root.rightNode;
        tnode.leftNode = new Node("F");
        tnode.rightNode = new Node("G");

        tempNode = tnode.rightNode;  // rememebr "G"

        tnode = tnode.leftNode;
        tnode.leftNode = new Node("L");
        tnode.rightNode = new Node("M");

        tnode = tempNode;

        tnode.leftNode = new Node("N");
        tnode.rightNode = new Node("O");

        return root;
    }
}

import java.util.Stack；
公共类二叉树{
公共静态void main（字符串参数[]）
{
Node root=Node.createDummyTree（）；
节点tnode；//=根；
堆栈=新堆栈（）；
if（root！=null）
{
栈.推（根）；
}
而（！stack.isEmpty（））
{
tnode=stack.pop（）；
if（tnode！=null）
{
System.out.println（tnode.value）；
if（tnode.rightNode！=null）
{
stack.push（tnode.rightNode）；
}
if（tnode.leftNode！=null）
{
stack.push（tnode.leftNode）；
}
}
}
}
}
类节点{
公共节点leftNode；
公共节点rightNode；
公共字符串值；
节点（字符串值）
{
这个值=值；
}
/**
*构造一个虚拟二叉树
*A
*          /         \
*B C
*       /   \       /   \
*D E F G
*     / \   / \   / \   / \
*H I J K L M N O
*@返回
*/
公共静态节点createDummyTree（）{
节点根=新节点（“A”）；
root.leftNode=新节点（“B”）；
root.rightNode=新节点（“C”）；
Node tnode=root.leftNode；
tnode.leftNode=新节点（“D”）；
tnode.rightNode=新节点（“E”）；
Node tempNode=tnode.rightNode；//记住“E”
tnode=tnode.leftNode；
tnode.leftNode=新节点（“H”）；
tnode.rightNode=新节点（“I”）；
tnode=tempNode；
tnode.leftNode=新节点（“J”）；
tnode.rightNode=新节点（“K”）；
tnode=root.rightNode；
tnode.leftNode=新节点（“F”）；
tnode.rightNode=新节点（“G”）；
tempNode=tnode.rightNode；//rememebr“G”
tnode=tnode.leftNode；
tnode.leftNode=新节点（“L”）；
tnode.rightNode=新节点（“M”）；
tnode=tempNode；
tnode.leftNode=新节点（“N”）；
tnode.rightNode=新节点（“O”）；
返回根；
}
}

非常感谢，这些评论帮助我更好地理解了它的工作原理：）这是一个预顺序遍历，但OP指的是顺序遍历。

import java.util.Stack;

public class BinaryTree {

    public static void main(String args[])
    {
        Node root = Node.createDummyTree();
        Node tnode; //= root;

        Stack<Node> stack = new Stack<Node>();

        if (root != null)
        {
            stack.push(root);
        }

        while (!stack.isEmpty())
        {
            tnode = stack.pop();

            if (tnode != null)
            {
                System.out.println(tnode.value);

                if(tnode.rightNode != null)
                {
                    stack.push(tnode.rightNode);
                }

                if (tnode.leftNode != null)
                {
                    stack.push(tnode.leftNode);
                }
            }
        }
    }

}

class Node {
    public Node leftNode;
    public Node rightNode;
    public String value;

    Node(String value)
    {
        this.value = value;
    }

    /**
     *  Construct a dummy binary Tree
     *               A
     *          /         \
     *         B           C
     *       /   \       /   \
     *      D     E     F     G
     *     / \   / \   / \   / \
     *    H   I J   K  L  M  N  O

     * @return
     */

    public static Node createDummyTree(){

        Node root = new Node("A");
        root.leftNode = new Node("B");
        root.rightNode = new Node("C");

        Node tnode = root.leftNode;
        tnode.leftNode = new Node("D");
        tnode.rightNode = new Node("E");

        Node tempNode = tnode.rightNode;  //remember "E"  

        tnode = tnode.leftNode;
        tnode.leftNode = new Node ("H");
        tnode.rightNode = new Node ("I");

        tnode = tempNode;

        tnode.leftNode = new Node ("J");
        tnode.rightNode = new Node ("K");

        tnode = root.rightNode;
        tnode.leftNode = new Node("F");
        tnode.rightNode = new Node("G");

        tempNode = tnode.rightNode;  // rememebr "G"

        tnode = tnode.leftNode;
        tnode.leftNode = new Node("L");
        tnode.rightNode = new Node("M");

        tnode = tempNode;

        tnode.leftNode = new Node("N");
        tnode.rightNode = new Node("O");

        return root;
    }
}