数据结构-二叉树的遍历

二叉树的三种遍历顺序

有三种简单的顺序遍历：前序，中序，后序。

中序遍历

1. 遍历左子树
2. 访问根节点
3. 遍历右子树

结果：4251637

递归遍历

public void inOrder(TreeNode root){
        if (root != null){
            inOrder(root.leftChild);
            //对节点的操作
            System.out.println(root.idata);
            inOrder(root.rightChild);
        }
    }

非递归遍历

   public void middle(TreeNode root){
        Stack<TreeNode> res = new Stack<>();
        List list = new ArrayList<Integer>();
        TreeNode node = root;
        TreeNode temp = new TreeNode();
        while(node != null || !res.isEmpty()){
            //一直遍历左子树，并将节点入栈，直到左子树为null
            while (node !=null){

                res.push(node);
                node = node.leftChild;
            }
            //左子树为null时，pop出栈顶节点（这里我把pop出来的节点的值放入列表中，用于打印出来）
            temp = res.pop();
            list.add(temp.idata);
            //然后遍历其右子树。
            node = temp.rightChild;
        }
        for (Object i:list){
            System.out.println(i);
        }
    }

前序遍历

1. 访问根节点
2. 遍历左子树
3. 遍历右子树

结果：1245367

递归遍历

    public void firstErgodic(TreeNode root){
        if (root != null){
            //对节点的操作
            System.out.println(root.idata);
            firstErgodic(root.leftChild);
            firstErgodic(root.rightChild);
        }

非递归遍历

    public void first(TreeNode root){
        Stack<TreeNode> res = new Stack<>();
        List list = new ArrayList<Integer>();
        TreeNode node = root;
        TreeNode temp = new TreeNode();
        while(node != null || !res.isEmpty()){
            //一直遍历左子树，并将节点入栈，直到左子树为null
            while (node !=null){
                res.push(node);
                list.add(node.idata);
                node = node.leftChild;
            }
            //左子树为null时，pop出栈顶节点（这里我把pop出来的节点的值放入列表中，用于打印出来）
            temp = res.pop();
            //然后遍历其右子树。
            node = temp.rightChild;
        }
        for (Object i:list){
            System.out.println(i);
        }
    }

后序遍历

1. 遍历左子树
2. 遍历右子树
3. 访问根节点

结果：4526731

递归遍历

    public void lastErgodic(TreeNode root){
        if (root != null){
            lastErgodic(root.leftChild);
            lastErgodic(root.rightChild);
            //对节点的操作
            System.out.println(root.idata);
        }
    }

非递归遍历

根据百度百科词条：“后序遍历” 中的算法改编

    public void last(TreeNode root){
        if (root == null){
            return ;
        }
        Stack<TreeNode> res = new Stack<>();
        List list = new ArrayList<Integer>();
        TreeNode node = root;
        TreeNode temp = new TreeNode();
        int flag;
        do {
            
            while (node !=null){
                res.push(node);
                node = node.leftChild;
            }
            flag = 1;
            temp = null;
            while (flag==1&&!res.isEmpty()){
                node = res.peek();
                if (node.rightChild == temp){
                    list.add(node.idata);
                    res.pop();
                    temp= node;
                }else {
                    node= node.rightChild;
                    flag = 0;
                }
            }
        }while (!res.isEmpty());
        for (Object i:list){
            System.out.println(i);
        }
    }