二叉树遍历

基础概念

• 满二叉树
• 完全二叉树
• 二叉搜索树：
  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  • 它的左、右子树也分别为二叉排序树。
• 平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。红黑树就是一种二叉平衡搜索树

遍历

前中后的递归遍历

public List<Integer> preOrderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }
    private void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {return;}
        res.add(root.val);    //前中后换这个代码位置即可
        preorder(root.left, res);
        preorder(root.right, res);
    }

前序非递归遍历

白话：前序遍历的顺序是 中左右的顺序，因为栈的顺序是后进先出，所以处理完“中”节点，先把右节点塞进去，再后塞左边的节点。这样先pop出来的是左边的节点。大循环的条件就是栈是否为空。

public List<Integer> preorderNonRecursive(TreeNode root){
        List<Integer> res =new ArrayList<>();
        if(root==null)return res;
        Stack<TreeNode> s=new Stack<>() ;
        s.push(root);
        while(!s.isEmpty()){
            TreeNode node=s.pop();
            res.add(node.val);
            if(node.right!=null)s.push(node.right);
            if(node.left!=null)s.push(node.left);
        }
        return res;
    }

后序非递归遍历

白话：前序遍历实现的是中左右，调换两行代码顺序可以实现中右左的遍历。如果我们把这种遍历的结果reverse一下就是左右中，即后续遍历

  public List<Integer> postOrderNonRecursive(TreeNode root){
        List<Integer> res =new ArrayList<>();
        if(root==null)return res;
        Stack<TreeNode> s=new Stack<>() ;
        s.push(root);
        while(!s.isEmpty()){
            TreeNode node=s.pop();
            res.add(node.val);
            if(node.left!=null)s.push(node.left);
            if(node.right!=null)s.push(node.right);
        }
        Collections.reverse(res);
        return res;

中序非递归遍历

白话：cur指向root，（大循环条件就是cur不为null或栈非空）{（小循环cur为空）{ 塞入cur，cur指向cur的左节点，然后一直往左下指，往栈里塞节点，直到遇到一个null}，此时pop出来的一定是最左下的节点，而且这个节点没有左节点了，处理当前节点，然后把cur指向该节点的右节点。}

 public List<Integer> inorderNonRecursive(TreeNode root){
        List<Integer> res= new ArrayList<>();
        Stack<TreeNode> s =new Stack<>();
        TreeNode cur =root;
        while(cur!=null||!s.isEmpty()){
            while(cur!=null){
                s.push(cur);
                cur=cur.left;
            }
            cur=s.pop();
            res.add(cur.val);
            cur=cur.right;
        }
        return res;
    }

层次遍历

白话：从队列的取一个节点，处理塔，然后并塞入左节点，右节点。

 public List<Integer> levelTra(TreeNode root){
        List<Integer> res =new ArrayList<>();
        Queue<TreeNode> d = new ArrayDeque<>();
        d.add(root);
        while(!d.isEmpty()){
            TreeNode node = d.poll();
            res.add(node.val);
            if(node.left!=null)d.add(node.left);
            if(node.right!=null)d.add(node.right);
        }
        return res;
    }

Z形遍历

白话：从2、3层通过观察可以知道，对于每一层来说，最后处理的节点的子节点先被处理，是栈的特点。然后它的顺序会变化，一层从左往右，一层从右往左。我直接用了2个栈，一个栈往另一个栈塞节点，调换了一个塞节点的顺序即可

 public List<Integer> zTra(TreeNode root){
        List<Integer> res =new ArrayList<>();
        Stack<TreeNode> s1 =new Stack<>();
        Stack<TreeNode> s2 =new Stack<>();
        s2.add(root);
        //s1.add(root);
        while(true){
            while(!s1.isEmpty()){
                TreeNode node = s1.pop();
                res.add(node.val);
                if(node.left!=null)s2.add(node.left);
                if(node.right!=null)s2.add(node.right);
            }
            while(!s2.isEmpty()){
                TreeNode node = s2.pop();
                res.add(node.val);
                if(node.right!=null)s1.add(node.right);
                if(node.left!=null)s1.add(node.left);
            }
            if(s1.isEmpty()&&s2.isEmpty())break;
        }
        return res;