码迷,mamicode.com
首页 > 其他好文 > 详细

二叉树的先序、中序以及后序遍历(递归 && 非递归)

时间:2016-06-02 19:43:44      阅读:147      评论:0      收藏:0      [点我收藏+]

标签:

树节点定义:

class TreeNode {
         int val;
         TreeNode left;
         TreeNode right;
         TreeNode(int x) { 
         val = x; 
         }
     }

递归建立二叉树:

    //递归建立二叉树
    public static void BuildTree(TreeNode node, int data){
        if(node == null){
            node = new TreeNode(data);
        }
        
        if(data <= node.val){
            if(node.left == null){
                node.left = new TreeNode(data);
            }else{
                BuildTree(node.left, data);
            }
        }
        
        if(data > node.val){
            if(node.right == null){
                node.right = new TreeNode(data);
            }else{
                BuildTree(node.right, data);
            }
        }    
    }

 

 

1、先序遍历

遍历方式:根节点-->左节点-->右节点

递归先序遍历:

    //先序递归遍历二叉树
    public static List<Integer> preTravese(TreeNode root,List<Integer> arr){
        if(root == null)
            return arr;
        if(root != null){
            arr.add(root.val);
            arr = preTravese(root.left,arr);
            arr = preTravese(root.right,arr);
        }
        return arr;
    }

非递归遍历:

对于任意一个结点p

1)访问结点p,并将p入栈

2)将p变为p的左孩子结点,如果p的不为空,循环至 1); 否则弹出当前栈顶使用p接收,将p变为p的右孩子结点;

3)当p结点为null并且栈为空时,结束循环。

代码:

    //非递归先序遍历
    public static List<Integer> preorderTraversal(TreeNode root){
        List<Integer> arr = new ArrayList<Integer>();
        if(root == null){
            return arr;
        }
        Stack<TreeNode> ts = new Stack<TreeNode>();
        TreeNode ptr = root;
        while( ptr != null || !ts.isEmpty()){
            while(ptr != null){
                arr.add(ptr.val);
                ts.push(ptr);
                ptr = ptr.left;
            }
            if( !ts.isEmpty()){
                ptr = ts.pop();
                ptr = ptr.right;
            }
        }
        return arr;
    }

 

 

2、中序遍历

遍历方式: 左子树-->根节点-->右子树

递归中序遍历:

    //中序递归遍历二叉树
    public static List<Integer> inTravese(TreeNode root,List<Integer> arr){
        if(root == null)
            return arr;
        if(root != null){
            arr = inTravese(root.left,arr);
            arr.add(root.val);
            arr = inTravese(root.right,arr);
        }
        return arr;
    }

非递归中序遍历:

对于任意一个结点p

1)当结点不为null,将结点压栈;

2)将p更新为它的左孩子,如果左孩子不为空,循环至 1);否则弹出栈顶元素赋值给p,访问p结点,p更新为p的右孩子;

3)当p为null 并且栈为空时结束循环。

代码:

    //中序非递归遍历
    public static List<Integer> inorderTraversal(TreeNode root){
        List<Integer> arr = new ArrayList<Integer>();
        if(root == null){
            return arr;
        }
        Stack<TreeNode> ts = new Stack<TreeNode>();
        TreeNode ptr = root;
        while( ptr != null || !ts.isEmpty() ){
            while(ptr != null){
                ts.push(ptr);
                ptr = ptr.left;
            }
            if(!ts.isEmpty()){
                ptr = ts.pop();
                arr.add(ptr.val);
                ptr = ptr.right;
            }
        }
        return arr;
    }

 

3、后序遍历

遍历方式:左子树-->右子树-->根节点

递归遍历:

    //后序递归遍历二叉树
    public static List<Integer> lastTravese(TreeNode root,List<Integer> arr){
        if(root == null)
            return arr;
        if(root != null){
            arr = lastTravese(root.left,arr);
            arr = lastTravese(root.right,arr);
            arr.add(root.val);
        }
        return arr;
    }

非递归遍历:

对于任一结点P,将其入栈,然后沿其左子树一直往下搜索,直到搜索到没有左孩子的结点,此时该结点出现在栈顶,但是此时不能将其出栈并访问,因为其右孩子还没有被访问。

接下来按照相同的规则对其右子树进行相同的处理,当访问完其右孩子时,该结点又出现在栈顶,此时可以将其出栈并访问。

这样就可以保证正确的访问顺序。

可以看出,在这个过程中,每个结点都两次出现在栈顶,只有在第二次出现在栈顶时,才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

代码:

首先新建一个类来记录结点是否是第一次弹栈:

//新建一个类,用来记录该结点是不是第一次弹栈
class NewTreeNode{
    TreeNode ptr;
    boolean isFirst;
    public NewTreeNode(TreeNode ptr){
        this.ptr = ptr;
        this.isFirst = true;
    }
}

非递归后序遍历二叉树:

    //后序非递归遍历二叉树
    public static List<Integer> lastTraverse(TreeNode root){
        List<Integer> arr = new ArrayList<Integer>();
        if(root == null){
            return arr;
        }
        Stack<NewTreeNode> nts = new Stack<NewTreeNode>();
        NewTreeNode nptr = null;
        TreeNode ptr = root;
        while( ptr!= null || !nts.isEmpty()){
            while(ptr != null){
                nptr = new NewTreeNode(ptr);
                nts.push(nptr);
                ptr = ptr.left;
            }
            
            if(!nts.isEmpty()){
                nptr = nts.pop();
                if(nptr.isFirst){
                    nptr.isFirst = false;
                    nts.push(nptr);
                    ptr = nptr.ptr.right;
                }else{
                    arr.add(nptr.ptr.val);
                    //ptr置为null,因为此时它的左右子树都已经访问完毕
                    ptr = null;
                }
            }
        }
        return arr;
    }

}

 

二叉树的先序、中序以及后序遍历(递归 && 非递归)

标签:

原文地址:http://www.cnblogs.com/bywallance/p/5553946.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!