zoukankan      html  css  js  c++  java
  • 二叉树的四种遍历

    树的遍历

    前序遍历

    递归

    import java.util.ArrayList;
    import java.util.List;
    
    class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            if (root != null) {
                list.add(root.val);
                list.addAll(preorderTraversal(root.left));
                list.addAll(preorderTraversal(root.right));
            }
            return list;
        }
    }
    

    迭代

    模板 1:

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            TreeNode cur = root;
            while (cur != null || !stack.isEmpty()) {
                // 依次访问左侧链,并将其压入栈中
                while (cur != null) {
                    list.add(cur.val); // 访问
                    stack.push(cur); // 入栈
                    cur = cur.left; // 传递
                }
                // 对栈中节点的右侧进行迭代
                cur = stack.pop();
                cur = cur.right;
            }
            return list;
        }
    }
    

    模板 2:

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            while (root != null || !stack.isEmpty()) {
                if (root != null) {
                    list.add(root.val);
                    stack.push(root);
                    root = root.left;
                } else {
                    root = stack.pop();
                    root = root.right;
                }
            }
            return list;
        }
    }
    

    中序遍历

    递归

    import java.util.ArrayList;
    import java.util.List;
    
    class Solution {
        public List<Integer> inorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            if (root != null) {
                list.addAll(inorderTraversal(root.left));
                list.add(root.val);
                list.addAll(inorderTraversal(root.right));
            }
            return list;
        }
    }
    

    迭代

    模板 1:

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> inorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            TreeNode cur = root;
            while (cur != null || !stack.isEmpty()) {
                // 将左侧节点依次入栈
                while (cur != null) {
                    stack.push(cur);
                    cur = cur.left;
                }
                // 从最左节点开始访问
                cur = stack.pop();
                list.add(cur.val);
                // 紧接着对右子树执行此迭代
                cur = cur.right;
            }
            return list;
        }
    }
    

    模板 2:

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> inorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            while (root != null || !stack.isEmpty()) {
                if (root != null) {
                    stack.push(root);
                    root = root.left;
                } else {
                    root = stack.pop();
                    list.add(root.val);
                    root = root.right;
                }
            }
            return list;
        }
    }
    

    后序遍历

    递归

    import java.util.ArrayList;
    import java.util.List;
    
    class Solution {
        public List<Integer> postorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            if (root != null) {
                list.addAll(postorderTraversal(root.left));
                list.addAll(postorderTraversal(root.right));
                list.add(root.val);
            }
            return list;
        }
    }
    

    迭代

    模板 1:

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> postorderTraversal(TreeNode root) {
            List<Integer> list = new ArrayList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            TreeNode cur = root;
            TreeNode p = null;//用来记录上一节点
            while (!stack.isEmpty() || cur != null) {
                while (cur != null) {
                    stack.push(cur);
                    cur = cur.left;
                }
                cur = stack.peek();
                // 后序遍历的过程中在遍历完左子树跟右子树cur都会回到根结点。
                // 所以当前不管是从左子树还是右子树回到根结点都不应该再操作了,应该退回上层。
                // 如果是从右边再返回根结点,应该回到上层。
                // 主要就是判断出来的是不是右子树,是的话就可以把根节点=加入到list了
                if (cur.right == null || cur.right == p) {
                    list.add(cur.val);
                    stack.pop();
                    p = cur;
                    cur = null;
                } else {
                    cur = cur.right;
                }
            }
            return list;
        }
    }
    

    模板 2:

    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<Integer> postorderTraversal(TreeNode root) {
            LinkedList<Integer> list = new LinkedList<>();
            Deque<TreeNode> stack = new LinkedList<>();
            while (root != null || !stack.isEmpty()) {
                if (root != null) {
                    list.addFirst(root.val);
                    stack.push(root);
                    root = root.right;
                } else {
                    root = stack.pop();
                    root = root.left;
                }
            }
            return list;
        }
    }
    

    层序遍历

    递归:反人类,没必要

    迭代

    import java.util.ArrayList;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.List;
    
    class Solution {
        public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> result = new ArrayList<>();
            Deque<TreeNode> deque = new LinkedList<>();
            deque.offerLast(root);
            while (!deque.isEmpty()) {
                int size = deque.size();
                List<Integer> list = new LinkedList<>();
                while (size-- > 0) {
                    TreeNode treeNode = deque.pollFirst();
                    if (treeNode == null) continue;
                    list.add(treeNode.val);
                    deque.offerLast(treeNode.left);
                    deque.offerLast(treeNode.right);
                }
                if (list.size() > 0) result.add(list);
            }
            return result;
        }
    }
    
  • 相关阅读:
    ActiveMQ 即时通讯服务 浅析
    Asp.net Mvc (Filter及其执行顺序)
    ActiveMQ基本介绍
    ActiveMQ持久化消息的三种方式
    Windows Azure Virtual Machine (27) 使用psping工具,测试Azure VM网络连通性
    Azure China (10) 使用Azure China SAS Token
    Windows Azure Affinity Groups (3) 修改虚拟网络地缘组(Affinity Group)的配置
    Windows Azure Storage (22) Azure Storage如何支持多级目录
    Windows Azure Virtual Machine (26) 使用高级存储(SSD)和DS系列VM
    Azure Redis Cache (2) 创建和使用Azure Redis Cache
  • 原文地址:https://www.cnblogs.com/varc/p/15643259.html
Copyright © 2011-2022 走看看