数据结构与算法---二叉树的周游

数据结构与算法—二叉树的周游

二叉树数据类型的定义：

/*Definition for a binary tree node.*/
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;
    }
 }

1.二叉树前序遍历：根、左、右

递归方式：

递归方式遍历二叉树是非常简单的，符合人的逻辑思维，非常像人类的语言。

public class Test {
    public void preOrder(TreeNode root,List<Integer> preList){
        //递归的出口
        if(root == null)
            return;
        //访问根结点
        preList.add(root.val);
        //访问左孩子
        preOrder(root.left,preList);
        //访问右孩子
        preOrder(root.right,preList);
    }
    
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> preList = new ArrayList<>();
        preOrder(root,preList);
        return preList;
    }
}

栈遍历方式：

栈的遍历方式，对于不同的周游方式有着不同的方法。
那么我们来思考一下前序遍历的特点：根 -> 左 -> 右，
我们到达某一个结点的第一件事情，就是访问它。然后再去看左子树，最后看右子树。栈的功能，实质上是保存现场，当我们正在某一棵二叉树，当走到其左子树时，我们同样采取根 -> 左 -> 右 的访问方式，结果发现，这个左子树还有子树，所以我们需要去访问子树的子树，那么我们就得记忆，我们在什么时刻被打断了。
通过分析，我们发现在“前序遍历”的时候，我们每次都是在
即将访问“我们此时身处的二叉树的右子树”时，被打断。那么我们应该记住：“刚才谁的右子树还没有被访问？” 替换成栈对应的说法就是：“栈顶元素是为了帮助我们走到上一步将要访问的右子树”。

public class Test {
    public List<Integer> preorderTraversal(TreeNode root) {
        //对于空树我们返回一个空的集合
        if(root == null){
            return new ArrayList<>();
        }
        //栈
        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        //访问的结果
        List<Integer> preList = new ArrayList<>();
        //临时存储
        TreeNode node = root;
        //栈会出现：栈为空，但仍未周游完毕的情况
        while (node != null || !stack.isEmpty()){
            //结点不为null，则访问结点，并加入到栈中，再前往其左子树
            while (node != null){
                preList.add(node.val);  //访问结点
                stack.push(node);   //加入到栈中
                node = node.left;   //前往其左子树
            }
            //退出循环，代表此时的栈顶元素左子树为空,取出栈顶元素
            node = stack.pop();
            //进入其右子树
            node = node.right;
        }
        return preList;
    }
}

2.二叉树中序遍历：左、根、右

递归方式：

同样非常简单

public class Test {
    public void inOrder(TreeNode root,List<Integer> inList){
    	//递归的出口
        if(root == null)
            return;
        //访问左孩子
        inOrder(root.left,inList);
        //访问根结点
        inList.add(root.val);
        //访问右孩子
        inOrder(root.right,inList);
    }
    
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> inList = new ArrayList<>();
        inOrder(root,inList);
        return inList;
    }
}

栈遍历方式：

不同于前序遍历，元素在进栈的时候不会立即被访问，而是要先访问该结点的左结点。有 “先把所有左结点收集起来” 的意味。

public class Test {
    public List<Integer> inorderTraversal(TreeNode root) {
        //空树，返回空集合
        if(root == null)
            return new ArrayList<>();
        //遍历的结果
        List<Integer> inList = new ArrayList<>();
        //栈
        Deque<TreeNode> stack = new LinkedList<>();
        //暂存
        TreeNode node = root;
        //可能出现为空但仍未遍历完的情况
        while (!stack.isEmpty() || node != null){
            //当结点不为空，一次将结点引入栈中,并前往左子树
            while (node != null){
                stack.push(node);
                node = node.left;
            }
            //退出循环，栈顶元素左子树为空，访问栈顶元素，前往其右子树
            node = stack.pop();
            inList.add(node.val);   //访问栈顶元素
            node = node.right;  //前往其右子树
        }
        return inList;
    }
}

3.二叉树后序遍历：左、右、根

递归方式：

同样很简单

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

栈遍历方式：

通过人脑遍历，可以发现后序遍历有两个特点，一个是：

1. 栈顶元素要出栈时，先要检查是否有右子树，如果有，则需要把栈顶重新压入，然后继续压入右子树。
2. 因为栈顶元素有可能被压回两次，所以，当被压了两次的元素再次出栈，他的右子树是已经出栈的元素，并且就在它之前出栈。所以此时若发现pre指向已经出栈了的元素，那么这个再次出栈的元素，直接出栈。

public class postOrderTraversal {
    public List<Integer> postorderTraversal(TreeNode root) {
        //处理无意义的输出
        if(root == null)
            return new ArrayList<Integer>();
        //遍历结果
        List<Integer> postList = new ArrayList<>();
        //栈
        Deque<TreeNode> stack = new LinkedList<>();
        //暂存
        TreeNode pre = root;
        //这种遍历情况也可能会导致栈空而未遍历完成
        while (!stack.isEmpty() || root != null){
            //收集所有的左结点
            while (root != null){
                stack.push(root);
                root = root.left;
            }
            //此时该结点的左子树为空，出栈
            root = stack.pop();
            //检查其右子树是否存在，或者该结点已经出过一次栈（右子树是不是上次出栈的）
            if (root.right == null || root.right == pre){
                //访问
                postList.add(root.val);
                //调整前驱
                pre = root;
                //root置为null方便迭代
                root = null;
            }else{
                //右子树存在且该结点第一次出栈，重新压入栈中
                stack.push(root);
                //进入右子树
                root = root.right;
            }
        }
        return postList;
    }
}

以上就是二叉树的三种遍历方式最常用的方法，希望对你有帮助。