Leetcode – 树的遍历总结(java)

原创 2015年11月19日 10:47:59

前序遍历

前序二叉树遍历是树的经典面试题,解决这个问题的关键是要了解:1、什么是前序遍历(访问孩子前先访问父节点)?2、使用java核心库的Stack。对于一些奇怪的例子前序遍历不是很明显。但是如果使用栈来写这个程序,每个元素如何压入和弹出的就很明显了。解决这个问题的关键是使用栈来存储左右孩子,首先压入右孩子,这样就可以处理完左孩子后处理它。

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}
 
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> returnList = new ArrayList<Integer>();
 
        if(root == null)
            return returnList;
 
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
 
        while(!stack.empty()){
        	
            TreeNode n = stack.pop();
            returnList.add(n.val);
 
            if(n.right != null){
                stack.push(n.right);
            }
            if(n.left != null){
                stack.push(n.left);
            }
 
        }
        return returnList;
    }
}

中序遍历

解决中序遍历的3个步骤:1、中序的顺序是左孩子->父节点-->右孩子;2、使用栈来记录节点;3、理解什么时候进栈和出栈
//定义一个二叉树
public class TreeNode {
     int val;
     TreeNode left;
     TreeNode right;
     TreeNode(int x) { val = x; }
 }
 
public class Solution {
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
    	//注意要重置声明的数据元素,因为对于每一个测试用例都会使用同一个实例
         ArrayList<Integer> lst = new ArrayList<Integer>();
 
        if(root == null)
            return lst; 
 
        Stack<TreeNode> stack = new Stack<TreeNode>();
        //定义一个指针来跟踪节点
        TreeNode p = root;
 
        while(!stack.empty() || p != null){
 
            if(p != null){
                stack.push(p);
                p = p.left;
            }else{
                TreeNode t = stack.pop();
                lst.add(t.val);
                p = t.right;
            }
        }
 
        return lst;
    }
}

递归版:
public class Solution {
    List<Integer> result = new ArrayList<Integer>();
 
    public List<Integer> inorderTraversal(TreeNode root) {
        if(root !=null){
            helper(root);
        }
 
        return result;
    }
 
    public void helper(TreeNode p){
        if(p.left!=null)
            helper(p.left);
 
        result.add(p.val);
 
        if(p.right!=null)
            helper(p.right);
    }
}

后续遍历

在前序、中序和后续遍历问题中,后续遍历是最复杂的。解决后续遍历问题的步骤如下:1、后续遍历的顺序是左孩子->右孩子->父节点;2、找到先前访问节点和当前节点的关系;3、使用栈来跟踪节点。
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if(root==null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode temp = stack.peek();
            if(temp.left==null && temp.right==null) {
                TreeNode pop = stack.pop();
                res.add(pop.val);
            }
            else {
                if(temp.right!=null) {
                    stack.push(temp.right);
                    temp.right = null;
                }
                if(temp.left!=null) {
                    stack.push(temp.left);
                    temp.left = null;
                }
            }
        }
        return res;
    }
}


层次遍历

很明显要使用队列来解决这个问题,但是如果我们使用一个队列我们不能追踪每一层的开始,所以我们使用两个队列分别追踪当前层和下一层
public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
    ArrayList<ArrayList<Integer>> al = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> nodeValues = new ArrayList<Integer>();
    if(root == null)
        return al;
 
    LinkedList<TreeNode> current = new LinkedList<TreeNode>();
    LinkedList<TreeNode> next = new LinkedList<TreeNode>();
    current.add(root);
 
    while(!current.isEmpty()){
        TreeNode node = current.remove();
 
        if(node.left != null)
            next.add(node.left);
        if(node.right != null)
            next.add(node.right);
 
        nodeValues.add(node.val);
        if(current.isEmpty()){
            current = next;
            next = new LinkedList<TreeNode>();
            al.add(nodeValues);
            nodeValues = new ArrayList();
        }
 
    }
    return al;
}


参考:http://www.programcreek.com/2012/12/leetcode-solution-of-iterative-binary-tree-postorder-traversal-in-java/


LeetCode总结 -- 树的遍历篇

遍历树的数据结构中最常见的操作, 可以说大部分关于树的题目都是围绕遍历进行变体来解决的。 一般来说面试中遇到树的题目是用递归来解决的, 不过如果直接考察遍历, 那么一般递归的解法就过于简单了, 面试官...
  • linhuanmars
  • linhuanmars
  • 2014年08月12日 09:10
  • 12562

LeetCode总结 -- 二叉查找树篇

这篇总结主要介绍一个比较常见的数据结构--二叉查找树。二叉查找树既是一颗树,又带有特别的有序性质,所以考察的方式比较多而且灵活,属于面试题目中的常客。LeetCode中关于二叉查找树的题目有以下几道:...
  • linhuanmars
  • linhuanmars
  • 2014年09月25日 09:37
  • 13860

LeetCode总结,二叉树各种类型问题小结

1,三大基础遍历方式 三个遍历的博客地址, 1) 144/145/94 Binary Tree (Pre & In & Post) order Traversal 即: 前序遍历,总是先访...
  • EbowTang
  • EbowTang
  • 2016年05月24日 10:49
  • 3090

leetcode | 二叉树的前序遍历、中序遍历、后续遍历的非递归实现

Binary Tree Preorder Traversal:https://leetcode.com/problems/binary-tree-preorder-traversal/ Binary...
  • quzhongxin
  • quzhongxin
  • 2015年06月01日 19:20
  • 1343

【LeetCode-面试算法经典-Java实现】【145-Binary Tree Postorder Traversal(二叉树非递归后序遍历)】

【144-Binary Tree Postorder Traversal(二叉树非递归后序遍历)】【LeetCode-面试算法经典-Java实现】【所有题目目录索引】原题  Given a binar...
  • DERRANTCM
  • DERRANTCM
  • 2015年08月19日 06:56
  • 2224

[LeetCode]106 根据中序遍历和后序遍历构建二叉树

Construct Binary Tree from Inorder and Postorder Traversal(根据中序遍历和后序遍历构建二叉树)【难度:Medium】 Given inord...
  • qq_14821023
  • qq_14821023
  • 2016年02月29日 14:23
  • 989

LeetCode总结,分治法总结

分治算法 一、基本概念 在计算机科学中,分治法是一种很重要的算法。字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问...
  • EbowTang
  • EbowTang
  • 2016年04月22日 11:30
  • 1235

LeetCode上与树相关的问题

前言没想到大三依然课业繁重,再加上一些琐事缠身,以及自身的惰性,不少计划都是心有余力不足,但又不愿这么混下去,近来回顾了一下自己在学习算法技能树上的加点,发现一些基础算法与经典算法实在是有那么点囫囵吞...
  • qq_15714857
  • qq_15714857
  • 2016年05月18日 21:12
  • 3118

二叉树遍历总结

二叉树遍历总结 1,前序遍历递归与非递归解法 1.1 前序遍历递归写法 /** * Definition for a binary tree node. * struct TreeNode...
  • JANESTAR
  • JANESTAR
  • 2016年04月08日 14:07
  • 791

LeetCode总结 -- 树的构造篇

这篇总结主要介绍树中比较常见的一类题型--树的构造。其实本质还是用递归的手法来实现,但是这类题目有一个特点,就是它是构建一棵树,而不是给定一棵树,然后进行遍历,所以实现起来思路上有点逆向,还是要练习一...
  • linhuanmars
  • linhuanmars
  • 2014年11月12日 10:40
  • 13846
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Leetcode – 树的遍历总结(java)
举报原因:
原因补充:

(最多只允许输入30个字)