常用数据结构算法：二叉树的遍历（递归和非递归）

最新推荐文章于 2024-04-08 22:10:05 发布

baju9371

最新推荐文章于 2024-04-08 22:10:05 发布

阅读量178

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/WellHold/p/6594779.html

版权

　　二叉树是常用的一种数据结构，今天记录一下学习到的二叉树的遍历方法，其中包括递归方式和非递归方式的遍历，这是在遍历方法上的分类。在遍历顺序上分类，二叉树的遍历可以分为前序、中序、后序遍历。所谓的前中后是指何时访问中间节点，即前序遍历，则遍历节点的顺序为：中-》左-》右；而中序遍历，则遍历节点的顺序为：左-》中-》右；以此类推，后序遍历的节点的顺序为：左-》右-》中。

　　一般常用的二叉树遍历的方法为递归的方式，因为其思路简单，且代码实现也十分简易，这里不再赘述，直接上代码：

//后序遍历，左=》右=》根
    public void postorder_Traversal(TreeNode root)
    {
        if(root==null)return;
        postorder_Traversal(root.left);
        postorder_Traversal(root.right);
        
         //访问节点的逻辑代码块
        System.out.print(root.val+" ");
    }
    //前序遍历，根=》左=》右
    public void preorder_Traversal(TreeNode root)
    {
        if(root==null)return;
        
        //访问节点的逻辑代码块
        System.out.print(root.val+" ");
        
        preorder_Traversal(root.left);
        preorder_Traversal(root.right);
    }
    //中序遍历，左=》根=》右
    public void inorder_Traversal(TreeNode root)
    {
        if(root==null)return;
        inorder_Traversal(root.left);
        
         //访问节点的逻辑代码块
        System.out.print(root.val+" ");
        
        inorder_Traversal(root.right);
    }

　　接下来要讲解的是非递归方式的遍历二叉树，相比递归方式，虽然非递归的方式遍历二叉树的思路比较复杂，并且实现也不易，但是非递归方式在效率方面，却比递归方式高出不少，特别是当二叉树十分庞大的时候，非递归方式可以很快的遍历完全整棵树，而递归方式则需要较长时间才能层层挖掘整棵树，那么接下来挨个上代码，通过代码讲解非递归方式。

//前序非递归遍历，根=》左=》右
    public void preorder(TreeNode root)
    {
        Stack<TreeNode>    stack=new Stack<>();
        while(root!=null||!stack.isEmpty())
        {
            //当前节点不为空，则入栈，确保最后遍历到的节点没有左子节点
            //因为是前序遍历，所以再遍历到每个节点的时候，都可以先访问，再寻找其左右子节点。
            while(root!=null)
            {
                System.out.print(root.val+" ");
                stack.push(root);
                root=root.left;
            }
            if(!stack.empty())
            {
                //把这两步看成是一步，找到右节点，并把已处理的中节点从stack当中去除
                root=stack.pop();
                root=root.right;
            }
        }
    }

从代码当中可以看出，我们借助栈这个先进后出的特性，来存储我们遍历过的节点。过程如下：

1.每遍历一个节点的时候，先节点入栈，然后寻找当前节点的左子节点。（因为是前序遍历，所以在节点入栈之前就可以对节点进行访问）

2.当某个节点的左子节点，当左子节点不为空的时候，重复过程1.

3.当左子节点为空的时候将当前节点出栈，并且通过其寻找右子节点，右子节点不为空的时候，重复过程1-2

4.当右子节点也为空的时候，则跳回上一个该节点的父节点（即因为当前节点已经出栈，所以现在在栈中最上层的节点是当前节点的父节点）

在了解完前序遍历之后，我们再看中序遍历代码：

//中序遍历非递归
    public void Inorder(TreeNode root)
    {
        Stack<TreeNode> stack=new Stack<>();
        while(root!=null||!stack.isEmpty())
        {
            //当前节点不为空，则入栈，确保最后遍历到的节点没有左子节点
            while(root!=null)
            {
                stack.push(root);
                root=root.left;
            }
            //通过当前节点，跳到当前节点的右节点，因为是中序遍历，所以当前节点没有左节点的时候，就可以访问当前节点
            if(!stack.empty())
            {
                root=stack.pop();
                System.out.print(root.val+" ");
                root=root.right;
            }
        }
    }

通过对比两个方法，发现代码几乎一模一样，但唯一的不同的是，访问节点的位置不一样，中序遍历是当左子节点被访问过，或者不存在的时候，才可以访问中间节点，所以再该处，访问节点的位置放在了当左子节点不存在的时候，即节点出栈的时候，即是左子节点不存在的时候进行访问。

最后我们来看看为难的非递归后序遍历，与前两个方法不同，后序遍历是需要左右子节点都遍历过后，才能访问中间节点，那么前边的一个栈就无法满足我们的要求了，因为我们需要一个标识位去确定是否是已经完成了左右子节点的遍历，结合代码，来理解这个方法：

//后序遍历非递归
    public void Postorder(TreeNode root)
    {
        Stack<TreeNode> s =new Stack<>(); 
        Stack<Integer> s2 =new Stack<>();
        Integer i=new Integer(1);
        while(root!=null||!s.isEmpty())
        {
            //只要当前节点非空，就入栈
            while(root!=null)
            {
                s.push(root);
                s2.push(new Integer(0));
                root=root.left;
            }
            //s2当中如果存1，则意味着当前s1对应的节点的左右子节点都已经遍历过了。
            while(!s.empty()&&s2.peek().equals(i))
            {
                s2.pop();
                System.out.print(s.pop().val+" ");
            }
            if(!s.isEmpty())
            {
                s2.pop();
                s2.push(new Integer(1));
                root=s.peek();
                root=root.right;
            }
            
        }
    }