数据结构-二叉树（java实现）及相关的oj题

---

树

在学习二叉树之前，先学习一下树的概念

树的定义：

树是一种数据结构，对比于生活中常见的树，其逻辑结构是倒立着的:
如图：

1. 树是由n个节点组成的有限集，（当n==0时，称此树为空树），对于任何一棵非空树，只有唯一的根节点root.
2. 当n>1时，除去根节点，剩余节点可以分为m个有限集（m>0),这些有限集互不相交，其中每个集合又是一棵树，称为根的子树。

关于树的相关概念：

树的实际实现形式（表现形式）

树结构相对于线性表比较复杂，要存储表示起来比较麻烦，有许多种表示方法，如：双亲表示法，孩子表示法，孩子双亲表示法，孩子兄弟表示法等等。
这里只介绍一下孩子兄弟表示法。

孩子兄弟表示法：
孩子兄弟表示法的思想是使得为每一个节点创建两个指针，一个指针指向此节点的第一个孩子节点
另一个指针指向此节点的兄弟节点，对于此节点的其他孩子节点则通过孩子节点的兄弟指针指向。
如图：

树的应用

我们电脑中的文件系统所采取的即树的思想：

二叉树

二叉树的概念

二叉树是一种特殊的树，与其它树不同的特性在于每一个节点最多有两个子节点。每一个节点的左树称为该节点的左子树，右树称为右子树，即：

从上图可以看出：

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

特殊的二叉树

有两种特殊的二叉树，满二叉树与完全二叉树

1. 满二叉树是指如果二叉树的每层节点数都达到最大值，称此二叉树为满二叉树。
   如图：
   
2. 完全二叉树是指对于一棵二叉树，其节点是根据从上到下，从左到右顺序排列的。

注：由两种特殊的二叉树性质可知，满二叉树是一种特殊的完全二叉树。

二叉树的性质：

这些二叉树的性质与算法设计紧密联系，应该熟练掌握。

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 2^(i - 1)(i>0)个结点。
2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是2^k-1 (k>=0)。
3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1。
   这条性质我们需要推导一下。
   
4. 具有N个结点的完全二叉树的深度k为log(N+1)以2为底向上取整。
   解：只有完全二叉树才可以根据节点个数推导二叉树的深度，推导过程：
   
   比如下面的这棵二叉树，log2(13+1) 取整，结果为4
   
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则 对于序号为i的结点有：
   若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点；
   若2i+1<n，左孩子序号：2i+1，否则无左孩子；
   若2i+2<n，右孩子序号：2i+2，否则无右孩子。

二叉树的存储实现：

二叉树的存储实现有两种情况，一种是顺序存储（在下节堆中讲到），另一种是链式存储
二叉树的链式存储是将节点都一个个连接起来，有两个引用与三个引用的情况：

// 孩子表示法
class Node {
    int val; // 数据域
    Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
    Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}
 
// 孩子双亲表示法
class Node {
    int val; // 数据域
    Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
    Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
    Node parent;    // 当前节点的双亲节点
}

二叉树的模拟实现：

实现的成员方法与属性：

public class BinaryTree {
    // 前序遍历
    public void preOrder(TreeNode root) {}
    // 中序遍历
    void inOrder(TreeNode root) {}
    // 后序遍历
    void postOrder(TreeNode root) {}
    // 获取节点的个数
    int size2(TreeNode root) {}
    //获取叶子节点的个数
    int getLeafNodeCount2(TreeNode root) {}
    //获取第K层节点的个数
    int getKLevelNodeCount(TreeNode root, int k) {}
    //获取二叉树的高度 时间复杂度：O(N)
    int getHeight(TreeNode root) {}
    // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, char val) {}
    //层序遍历
    void levelOrder(TreeNode root) {}
    // 判断一棵树是不是完全二叉树
    boolean isCompleteTree(TreeNode root) {}
}

实现节点内部类：

static class TreeNode {
        public char val;
        public TreeNode left;//左孩子的引用
        public TreeNode right;//右孩子的引用

        public TreeNode(char val) {
            this.val = val;
        }
    }

二叉树的遍历：

遍历二叉树有四种方式，分别是前序遍历，中序遍历，后序遍历，层序遍历
前序遍历是按照先根节点，然后左节点，然后右节点
中序遍历是先左节点，后根节点，然后右节点
后序遍历是先左节点，后右节点，然后根节点
二叉树不一定只有三个节点，所以这涉及递归的思想，在树的定义中，根节点的左节点即是左子树的根节点，这包含了递归的思想，所以二叉树的三种遍历可以通过递归的方式实现：
层序遍历即按照从上到下，从左到右，每一层地遍历二叉树。
前序遍历：
实现思想：遍历到当前节点时，先判断当前节点是否为空，不为空则打印此节点的数值，
并递归到本节点的左节点与右节点中去。

// 前序遍历
    public void preOrder(TreeNode root) {
        if (root == null) return;
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

中序遍历：
实现思想：遍历到当前节点时，判断当前节点是否为空，不为空，则先递归到当前节点的左节点中去，从左节点的方法返回时，再打印当前节点，然后再递归到右节点中去。

// 中序遍历
    void inOrder(TreeNode root) {
        if (root == null) return;
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

后序遍历
实现思想：遍历到当前节点时，判断当前节点是否为空，不为空，则先递归到当前节点的左节点中去，从左节点的方法返回时，再递归到右节点中去，当从左节点的方法与右节点的方法返回时，打印
根节点数值。

// 后序遍历
    void postOrder(TreeNode root) {
        if (root == null) return;
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

层序遍历：
问题： 如何找到当前节点的兄弟节点，并且能够返回到当前层的第一个节点的左节点，递归的思想实现不了，我们需要一个新的数据结构，能够储存节点。
实现思想：
进行层序遍历时，我们要用到队列（先进先出）这个数据结构，
从根结点开始先放进队列去。
然后将队列中节点取出打印，如果此节点的左右节点不为空，则将左右节点放入队列中，然后再循环往复，直到队列为空为止。

//层序遍历
    void levelOrder(TreeNode root) {
        if (root == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

获取节点的个数

实现思想：采用递归的思想，左子树节点个数+右子树节点个数+1，如果此节点为空，返回0.

int size2(TreeNode root) {
        if (root == null) return 0;
        return size2(root.left)
                + size2(root.right) + 1;
    }

获取叶子节点的个数

获取叶子节点的个数
实现思想：
采用递归的思想
如果树为空，返回0。
不为空，如果节点左子树和右子树为空则返回1。
最后返回根节点左子树和右子树的叶子结点之和。

int getLeafNodeCount2(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
    }

获取第k层节点的个数

思想：获取二叉树第k层的节点相当于获取其子树的k-1层节点，以此递归直至k=1.
实现思想：

1. 如果树为空，返回0。
2. 不为空，如果层数为1并且该节点不为空则返回1。（如果k为1，且此节点存在，则此树的节点即此节点为1）
3. 最后返回根节点左子树和右子树的第k-1层结点之和。

int getKLevelNodeCount(TreeNode root, int k) {
        if (root == null) return 0;
        if (k == 1) return 1;
        return getKLevelNodeCount(root.left, k - 1) +
                getKLevelNodeCount(root.right, k - 1);
    }

获取二叉树的高度

实现思想：通过递归思想，获取左子树高度与右子树高度，取两者最大值然后+1

int getHeight(TreeNode root) {
        if (root == null) return 0;
        int leftH = getHeight(root.left);
        int rightH = getHeight(root.right);
        return leftH > rightH ? leftH + 1 : rightH + 1;
    }

检查值为value的元素是否存在

 public TreeNode contains(TreeNode root , int val){
        //采用前序遍历
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }
        TreeNode b1 = contains(root.left);
        if(b1!=null){
            return b1;
        }
        TreeNode b2 = contains(root.right);
         if(b2!=null){
             return b2;
         }
        return null;
    }

判断一棵树是否是完全二叉树

实现思想：
在之前层序遍历的实现算法中，我们采用了一个新的数据结构，将每一个节点的非空子节点存储至队列中，对于判断完全二叉树，也可以通过一个队列，将遍历到的节点的左节点与右节点均放入队列中，无论其是否为空节点，然后将队列中的全部数据输出，如果发现空节点之后，还有数据说明此树非完全二叉树，没有，则说明此树为完全二叉树。

具体实现思想：

1. 如果根节点为空直接返回false。
2. 不为空将根放入队列。
3. 取出队列值，如果值不为空就将左孩子和右孩子（孩子是否为空不影响入队）入队，为空直接出循环。
4. 因为前面是拿到队列中的空节点出循环的，遍历剩余节点如果遇到不为空的节点那该树就不是完全二叉树。

boolean isCompleteTree(TreeNode root) {
        if (root == null) return false;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if (cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            } else {
                break;
            }
        }
        //第2次遍历队列 判断队列当中 是否存在非空的元素
        while(!queue.isEmpty()) {
            TreeNode cur = queue.peek();
            if (cur == null) {
                queue.poll();
            } else {
                return false;
            }
        }
        return true;
    }
}

二叉树相关的oj题

相同的树

实现思想：采用递归的思想，判断左子树与左子树相同，右子树与右子树相同，两个根节点也相同。

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p ==null&&q==null){
            return true;
        }
        //此时设计判断条件是为了下一条件避免空指针异常
        if((p !=null && q== null)||(p==null&&q!=null)){
            return false;
        }
        if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
            return true;
        }
         return false;
}
}

判断本树是否包含与另一棵树相同的子树

实现思想：遍历本树的每一个节点，然后以当前节点作为根节点判断与另一棵树是否相同
需要创建两个方法。一个用于遍历，一个用于比较。

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        //遍历整个二叉树，按照前序遍历的方式
        if(root == null){
            return false;
        }
        boolean b1  =   isSameTree(root,subRoot);
        if(b1 ==true){
            return true;
        }
        boolean b2  =     isSubtree(root.left,subRoot);
        if(b2 == true){
            return true;
        }
        boolean b3 = isSubtree(root.right,subRoot);
        if(b3 ==true){
            return true;
        }
        return false;
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p ==null&&q==null){
            return true;
        }
     //此时设计判断条件是为了下一条件避免空指针异常
        if((p !=null && q== null)||(p==null&&q!=null)){
            return false;
        }
        if(isSameTree(p.left,q.left)&&isSameTree(p.right,q.right)&&(p.val==q.val)){
            return true;
        }
         return false;
    }
}

翻转二叉树

实现思想：采用递归的思想，将每一个节点的左节点与右节点相互交换

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        TreeNode cur = root.left;
        root.left = root.right;
        root.right = cur;
        //将左子树与右子树，依次翻转
        invertTree(root.left);
        invertTree(root.right);
          return root;
    }
}

判断一棵二叉树是否是平衡二叉树

实现思想：在获取二叉树的高度的方法中，获取每一个节点的左子树高度与右子树高度之差，如果绝对值中出现大于的情况，返回-1 。

class Solution {
    public boolean isBalanced(TreeNode root) {
        return isBalanced2(root)!=-1;
     }
      public int isBalanced2(TreeNode root){
        if(root == null){
          return 0;
        }  
 
       int leftHeight = isBalanced2(root.left);
       if(leftHeight == -1){
        return -1;
       }
       int rightHeight = isBalanced2(root.right);
        if(rightHeight == -1){
           return -1;
       }
       if(Math.abs(leftHeight-rightHeight)>1){
           return -1;
       }

       return leftHeight>rightHeight ? leftHeight+1:rightHeight+1;

      }
   }

对称二叉树

实现思想：通过递归的思想，判断根节点的左节点的左子树与右节点的右子树，左节点的右子树与右节点的左子树是否相同。

class Solution {
    public boolean isSymmetric(TreeNode root) {
      return   isSymmetric2(root.left,root.right);
    }
    public boolean isSymmetric2(TreeNode r1 , TreeNode r2){
         if(r1 == null&&r2 == null){
            return true;
         }
         if( ( r1!= null&&r2 ==null)||      (r1==null&&r2!=null) ){
            return false;
}
         if(r1.val ==r2.val&& isSymmetric2(r1.left,r2.right)&&isSymmetric2(r1.right,r2.left)){
            return true ;
         }        
          
               return false;
    }
}

二叉树的构建与遍历

实现思想：通过递归算法，按照前序遍历的顺序进行节点创建并赋值，如果遇到#则跳过。

import java.util.Scanner;
class TreeNode {
    public TreeNode left;
    public TreeNode right;
    public char val;
    public TreeNode(char val) {
        this.val = val;
    }

}
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str = in.nextLine();
            TreeNode cur =  createtree(str);
            inOrder(cur);
        }
    }
    public static int i;
    public  static TreeNode createtree(String str) {
        //开始创建
          TreeNode  root = null;
        if (str.charAt(i) != '#') {
            root   =  new TreeNode(str.charAt(i));
            i++;
            root.left =  createtree(str);
            root.right = createtree(str);
            
        } else {
            i++;
        }
        return root;
    }
    public static void inOrder(TreeNode root) {
        if (root == null) {
              return;
        }
          inOrder(root.left);
          System.out.print(root.val + " ");
          inOrder(root.right);
    }
}

二叉树的分层遍历

实现思想：在之前的层序遍历中，我们是将在将每一个节点从队列中出去时，并将此节点的非空子节点输入到队列中，但是在本题中我们需要区分每一层之间的节点

1. 所以在输入完一层的节点后，我们需要先判断当前队列中的节点数量
2. 然后以此作为判断条件循环将当前队列中的值，输入到一个新的数组中去，并且将每一个节点的非空子节点输入到队列中去，将新的数组输入到二维数组中去。
3. 循环往复，直到队列为空。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list1 = new ArrayList<>();
      if(root == null){
            return list1;
        }
     LinkedList  <TreeNode> queue = new LinkedList();   //创建队列
     queue.offer(root);
     while (!queue.isEmpty()) {
           //打印队列中的节点
           //先获取队列中上一层节点的个数
            int len = queue.size();  
            List<Integer>list2 = new ArrayList<>();
           while(len>=1){
            //将队列1中队出的数据存入队列2中
           TreeNode cur = queue.poll();
           list2.add(cur.val);
           //然后将本节点左节点与右节点放入队列1中
           if (cur.left != null) {
               queue.offer(cur.left);
           }
           if (cur.right != null) {
               queue.offer(cur.right);
           }
         //最后将当前数组中的内容加入到二维数组中去
         
           len--;
       }
         list1.add(list2);
     }
     return list1;
    }
    }