java树形list获取所有根节点 java遍历树节点

文章目录

• 二叉树的遍历

• 二叉树节点定义
• 中序遍历

• 递归解法
• 迭代解法
• Morris中序遍历

• 前序遍历

• 递归解法
• 迭代解法

• 后序遍历

• 递归解法
• 迭代解法

二叉树的遍历

从根节点出发，按照某种次序依次访问二叉树中的所有的节点，使得每个节点被依次访问且只访问一次

• 前序（根，左，右）
• 中序（左，根，右）
• 后序（左，右，根）
• 层序：从根节点从上往下逐层遍历，同一层从左到右依次访问

其实这个“前，中，后”就指的是根节点的访问位置次序！！！

二叉树节点定义

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(){};
    TreeNode(int val){this.val=val;}
    TreeNode(int val,TreeNode left,TreeNode right){
        this.val=val;
        this.left=left;
        this.right=right;
    }
}

中序遍历

递归解法

递归的过程就是不断向左边走，当左边走不了就打印节点，并转向右边，然后右边继续这个过程。

• 终止条件：当前节点为空时
• 函数内：递归的调用左节点，打印当前节点，再递归调用右节点
• 时间复杂度：O(n)
• 空间复杂度：O(h)，h 是树的高度

public List<Integer> inorderTraversal(TreeNode root){
        List<Integer> res = new ArrayList<Integer>();
        inorder(root,res);
        return res;
    }
    public void inorder(TreeNode root,List<Integer> res){
        if (root==null){
            return;
        }
        inorder(root.left,res);
        res.add(root.val);
        inorder(root.right,res);
    }

迭代解法

用栈进行辅助，但是Java中都是利用Deque接口来替代Stack接口完成栈的功能的，我们可以发现deque的是继承自队列，而栈是继承自向量，Java中的Deuqe，即“双端队列”的缩写，是Java中的双端串联集合类型，它集成了自定队列，完全具有普通的FIFO的功能，同时它也具有堆栈的LIFO功能，并且保留了推弹出状语从句函数，所以使用起来应该是一点障碍都没有。Deque的可以由ArrayDeuqe或者LinkedList的实现，它们两者使用的区别以及优劣也就是数组和链表的区别。

在JavaDoc for Stack中这样说：

• Deque接口及其实现提供了一组更完整和一致的LIFO堆栈操作，应优先使用此类。例如：Deque stack = new ArrayDeque();

然后在JavaDoc for Deque中这样说：

• 双端队列也可以用作LIFO（后进先出）堆栈。此接口应优先于旧版Stack类使用。当双端队列用作堆栈时，元素从双端队列的开头被压入并弹出。

大概意思就是让我们不要再使用Stack接口去完成栈的功能，而是使用Deque，并提供了相关示例。

其实本质上这种方式和上面的递归是等价的，只是递归时候隐式地维护了一个栈，而我们在迭代的时候需要显示地将这个栈模拟出来，其他都相同：

• 时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。
• 空间复杂度：O(n)。空间复杂度取决于栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

public List<Integer> inorderTraversal(TreeNode root){
        List<Integer> res = new ArrayList<Integer>();
        Deque<TreeNode> stk = new LinkedList<TreeNode>();
        while (root!=null||!stk.isEmpty()){
            //根节点入栈然后左节点入栈直到左节点为空
            while (root!=null){
                stk.push(root);
                root = root.left;
            }
            //此时root == null
            //执行左出栈，因为此时root==null，所以root.right == null
            //执行下一次外层while代码块，根出栈，此时right可能存在
            //1.若root.right存在，右入栈再出栈
            //2.若root.right不存在，重复上面的步骤
            root = stk.pop();
            res.add(root.val);
            root = root.right;
        }
        return res;
    }

题解巧妙的使用了root = root->right，当right== nullptr时使得下一次跳过往左走的方向，继续出栈往右走。我觉得这种算法还是值得推敲的，其实也不太好理解，也不太好写。

Morris中序遍历

莫里斯遍历是二叉树遍历算法的超强进阶神级遍历算法，可以将空间复杂度下降为O(1)，没有使用任何辅助空间。它利用的是树的叶子节点左右孩子为空实现空间开销的极限缩减。

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        TreeNode predecessor = null;

        while (root != null) {
            if (root.left != null) {
                // predecessor 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
                predecessor = root.left;
                while (predecessor.right != null && predecessor.right != root) {
                    predecessor = predecessor.right;
                }
                
                // 让 predecessor 的右指针指向 root，继续遍历左子树
                if (predecessor.right == null) {
                    predecessor.right = root;
                    root = root.left;
                }
                // 说明左子树已经访问完了，我们需要断开链接
                else {
                    res.add(root.val);
                    predecessor.right = null;
                    root = root.right;
                }
            }
            // 如果没有左孩子，则直接访问右孩子
            else {
                res.add(root.val);
                root = root.right;
            }
        }
        return res;
    }

其实这种方法就是拿时间换空间，而且破坏了树的结构强行变成了链表，但空间没有时间那么重要，所以我觉得这种算法的实用性并不大，理解了就好。

前序遍历

递归解法

打印->左->右

public List<Integer> preorderTraversal1(TreeNode root){
        List<Integer> res =new ArrayList<Integer>();
        preorder(root,res);
        return res;
    }
    public void preorder(TreeNode root,List<Integer> res){
        if (root==null){
            return;
        }
        res.add(root.val);
        preorder(root.left,res);
        preorder(root.right,res);
    }

迭代解法

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return res;
    }

stack.push(node);

node = stack.pop();这两步可以好好看一下！

后序遍历

递归解法

左->右->打印

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root,res);
        return res;
    }
    public void postorder(TreeNode root,List<Integer> res){
        if(root==null){
            return;
        }
        postorder(root.left,res);
        postorder(root.right,res);
        res.add(root.val);
    }

迭代解法

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            //遍历到最左节点
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            //遍历最左节点的右子树（右子树存在&&未访问过）
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                //避免重复访问右子树[记录当前节点便于下一步对比]
                prev = root;
                //避免重复访问左子树[设空节点]
                root = null;
            } else {
                // 重复压栈以记录当前路径分叉节点
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }

行吧，这个迭代解法的难度是递增的，一个比一个难懂！！！