JAVA实现------二叉树的遍历，三种常见的遍历方式

个人理解二叉树的本质就是对于链表的一个进化，每一个非叶子节点节点都有左右两个子节点

遍历二叉树-----中序遍历

中序遍历就是先把左节点都访问完(左子树为空或者左节点为叶子节点)---->然后访问对应左叶子节点的根节点------>最后访问右节点------>依次递归遍历

public class ErChaShuDeBianLi01 {
    public static void main(String[] args) {
        TreeNode node1=new TreeNode(0);
        TreeNode node2=new TreeNode(1);
        TreeNode node3=new TreeNode(2);
        TreeNode node4=new TreeNode(3);
        TreeNode node5=new TreeNode(4);
        TreeNode node6=new TreeNode(5);

        node1.left=node2;
        node1.right=node3;
        node2.left=node4;
        node2.right=node5;
        node3.left=node6;

        Tree01 tree01 = new Tree01();
        List<Integer> res = tree01.inOrderTraversal02(node1);
        System.out.println(Arrays.toString(res.toArray()));

    }


}

class Tree01{
    public List<Integer> inOrderTraversal(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root,res);
        return res;
    }

    public List<Integer> inOrderTraversal02(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            res.add(root.val);
            root=root.right;

        }
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
        if(root==null){
            return;
        }
        accessTree(root.left,res);
        res.add(root.val);
        accessTree(root.right,res);
    }
}

遍历二叉树-----前序遍历

和中序遍历类似，只是先访问输出根节点，然后依次遍历该根节点的左节点和右节点

public class ErChaShuDeBianLi02 {
    public static void main(String[] args) {
        TreeNode node1=new TreeNode(0);
        TreeNode node2=new TreeNode(1);
        TreeNode node3=new TreeNode(2);
        TreeNode node4=new TreeNode(3);
        TreeNode node5=new TreeNode(4);
        TreeNode node6=new TreeNode(5);

        node1.left=node2;
        node1.right=node3;
        node2.left=node4;
        node2.right=node5;
        node3.left=node6;

        Tree02 tree01 = new Tree02();
        List<Integer> res = tree01.inOrderTraversal(node1);
        System.out.println(Arrays.toString(res.toArray()));

    }


}

class Tree02{
    public List<Integer> inOrderTraversal(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root,res);
        return res;
    }

    public List<Integer> inOrderTraversal02(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                res.add(root.val);
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            root=root.right;

        }
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
        if(root==null){
            return;
        }
        res.add(root.val);
        accessTree(root.left,res);
        accessTree(root.right,res);
    }
}

遍历二叉树-----后序遍历

先访问输出左节点，再访问输出右节点，再访问输出根节点，递归输出

public class ErChaShuDeBianLi03 {
    public static void main(String[] args) {
        TreeNode node1=new TreeNode(0);
        TreeNode node2=new TreeNode(1);
        TreeNode node3=new TreeNode(2);
        TreeNode node4=new TreeNode(3);
        TreeNode node5=new TreeNode(4);
        TreeNode node6=new TreeNode(5);

        node1.left=node2;
        node1.right=node3;
        node2.left=node4;
        node2.right=node5;
        node3.left=node6;

        Tree03 tree = new Tree03();
        List<Integer> res = tree.inOrderTraversal02(node1);
        System.out.println(Arrays.toString(res.toArray()));

    }


}

class Tree03{
    public List<Integer> inOrderTraversal(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root,res);
        return res;
    }

    public List<Integer> inOrderTraversal02(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        TreeNode preAccess=null;
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            if (root.right==null||root.right==preAccess) {
                res.add(root.val);
                preAccess=root;
                root=null;
            }
            else{
                stack.push(root);
                root=root.right;
            }
        }
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
        if(root==null){
            return;
        }
        accessTree(root.left,res);
        accessTree(root.right,res);
        res.add(root.val);
    }
}