二叉树的先序遍历(递归和非递归)、中序遍历(递归和非递归)、后序遍历(非递归)及层次遍历java实现

最新推荐文章于 2022-08-13 01:09:02 发布

原创最新推荐文章于 2022-08-13 01:09:02 发布 · 1.6k 阅读

2 ·

CC 4.0 BY-SA版权

LeetCode刷题专栏收录该内容

201 篇文章

订阅专栏

本文深入探讨了二叉树的遍历算法，包括先序、中序、后序及层次遍历的递归与非递归实现。通过具体代码示例，详细解析了每种遍历方式的实现原理与步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树的先序遍历，递归实现：

    public List<Integer> preorderTraversal(TreeNode root)   
    { //用栈来实现
        List<Integer> list = new ArrayList<Integer>();
        PreOrderTraversal(root,list);
        return list;
    }
    public void PreOrderTraversal(TreeNode root,List<Integer> list)
    {
        if(root == null)
            return;
        list.add(root.val);
        if(root.left != null)
            PreOrderTraversal(root.left,list);
        if(root.right != null)
            PreOrderTraversal(root.right,list);
    }

二叉树先序遍历，非递归实现：

    public static List<Integer> PreOrderTree(TreeNode root)
    {
        List<Integer> list = new ArrayList<Integer>();
        if(root == null)
            return list;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pCur = root;
        while(pCur != null || !stack.isEmpty())
        {
            list.add(pCur.val);
            stack.push(pCur);
            pCur = pCur.left;
            while(pCur == null && !stack.isEmpty())
            {
                pCur = stack.pop();
                pCur = pCur.right;
            }
        }
        return list;
    }

二叉树中序遍历，递归实现：

    public List<Integer> inorderTraversal(TreeNode root)
    {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        List<Integer> list = new ArrayList<Integer>();
        inOrderTraversal(root,stack,list);
        return list;
    }
    public void inOrderTraversal(TreeNode root,Stack<TreeNode> stack,List<Integer> list)
    {
        if(root == null)
            return;
        stack.push(root);   //先放根节点
        if(root.left != null)
            inOrderTraversal(root.left,stack,list);       //先判断父节点的左子树是否为空
        list.add(stack.pop().val);      //左子树为空，那么就将父节点压出栈，保存进list中
        if(root.right != null)                         //然后是遍历右子树
            inOrderTraversal(root.right,stack,list);
    }

二叉树的中序遍历，非递归实现：

    public static List<Integer> InOrderTree(TreeNode root)
    {
        List<Integer> list = new ArrayList<>();
        if(root == null)
            return list;
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pCur = root;
        while(pCur != null || !stack.isEmpty())
        {
            stack.push(pCur);
            pCur = pCur.left;
            while(pCur == null && !stack.isEmpty())
            {
                pCur = stack.peek().right;
                list.add(stack.pop().val);
            }
        }
        return list;
    }

二叉树的后序遍历，非递归实现：

    public static List<Integer> PostOrderTree(TreeNode root)
    {
        List<Integer> list = new ArrayList<>();
        if(root == null)
            return list;
        Stack<TreeNode> stack = new Stack<>();
        Boolean flag = false; //判断该节点是否已经被遍历过
        TreeNode pCur = root;
        TreeNode temp = null; 
        while(pCur != null)
        {
            stack.add(pCur);
            pCur = pCur.left;
            if(pCur == null)
            {
                flag = true;
                temp = null;
                while(!stack.isEmpty() && flag == true)
                {
                    pCur = stack.peek();
                    if(pCur.right == temp || pCur.right == null)
                    {
                        list.add(pCur.val);
                        temp = stack.pop();
                    }
                    else
                    {
                        pCur = pCur.right;
                        flag = false;
                    }
                }
                if(stack.isEmpty())
                    return list;
            }
        }
        return list;
    }

二叉树的层次遍历实现：

    public ArrayList<ArrayList<Integer>> levelOrder(Node root)   //层次遍历
    {
        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
        if(root == null)
            return list;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty())
        {
            int levelNum = queue.size();
            ArrayList<Integer> levelList = new ArrayList<>();
            for(int i = 0; i < levelNum; i++)
            {
                Node temp = queue.poll();
                levelList.add(temp.val);
                if(temp.children != null)
                    for(Node ele : temp.children)
                        queue.add(ele);
            }
            list.add(levelList);
        }
        return list;
    }