数据结构——二叉树

二叉树

1.基本介绍

1.1概念

一棵二叉树（非线性数据结构）是结点的一个有限集合，该集合：

1. 或者为空
2. 或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
   如图：
   
   注意：
3. 二叉树不存在度大于2的结点（一个结点含有子树的个数称为该结点的度）
4. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
5. 树的其他情况：
   

2.2 两种特殊的二叉树

1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵
   二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
   

2.3 二叉树的性质

1. 若规定根结点的层数为1，则一棵非空二叉树的第i层上最多有 (i>0)个结点
2. 若规定只有根结点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 (k>=0)
3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1
4. 具有n个结点的完全二叉树的深度k为 上取整
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i
   的结点有：
   若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点
   若2i+1<n，左孩子序号：2i+1，否则无左孩子
   若2i+2<n，右孩子序号：2i+2，否则无右孩子

2.4 二叉树的存储

二叉树的存储结构分为：顺序存储和类似于链表的链式存储。
实现如下：

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

2.5 二叉树的基本操作

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author zq
 * 二叉树
 */
public class TestBinaryTree {

    static class TreeNode{
        //孩子表示法
        public char val;
        public TreeNode left;
        public TreeNode right;
        //只有节点值的构造方法
        public TreeNode(char val){
            this.val = val;
        }
    }
   // public TreeNode root;//二叉树的根节点

    public TreeNode creatTree(){
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.left = F;
        C.right = G;
        E.right = H;
        //引用
        //this.root = A;
        //拿到根节点就能拿到树
        return A;
    }
    //前序遍历 根、左子树、右子树、递归
    public void preOrder(TreeNode root){
        if (root == null){
            return;
        }
        System.out.print(root.val);
        //移动根节点的位置，继续打印
        preOrder(root.left);
        //左边全部打印完毕，root == null
        // return；
        // 移动根节点位置打印右边
        preOrder(root.right);
    }
    //中序遍历，左子树，根，右子树
    public void inOrder(TreeNode root){
        if (root == null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.val+"");
        inOrder(root.right);
    }
    //后序遍历
    public void posOrder(TreeNode root){
        if (root == null){
            return;
        }
        posOrder(root.left);
        posOrder(root.right);
        System.out.print(root.val + "");
    }

    // 获取树中节点的个数,
    // 子问题：左树节点+右树节点＋1
    // 时间复杂度O(N),空间复杂度O(logN)
//    public int size(TreeNode root) {
//        if (root == null){
//            return 0;
//        }
//        int leftCount = size(root.left);
//
//        int  rightCount = size(root.right);
//        return leftCount + rightCount +1;
//    }

    //遍历思路
    int count = 0;
    public int size(TreeNode root) {

        if (root == null){
            return count;
        }
        count++;
        size(root.left);
        size(root.right);
        return count;
    }

    //求叶子节点个数
    //遍历
//    int count1 =0;
//    public int getLeafNodeCount(TreeNode root){
//        if (root == null){
//            return 0;
//        }
//        if (root.right==null && root.left==null){
//            count1++;
//        }
//        getLeafNodeCount(root.left);
//        getLeafNodeCount(root.right);
//        return count1;
//    }

    //子问题思路
    public int getLeafNodeCount(TreeNode root){
        if (root == null){
            return 0;
        }
        if (root.right==null && root.left==null){
            //遇到了就返回1，每个子节点都相当于一个子树，
            // 遍历左边有，就返回1，结束，然后遍历右边有，结束，返回1，
            // 然后返回左边加右边，
            return 1;
        }
      int leftcount =  getLeafNodeCount(root.left);
      int rightcount =   getLeafNodeCount(root.right);
        return rightcount +leftcount ;
    }

    //求第K层节点个数
    //子问题思路,
    // 求第k层节点个数相当于求第k-1层节点个数
    public int getKLevelNodeCount(TreeNode root,int k){
        if (root == null){
            return 0;
        }
        if (k==1){
            return 1;
        }
        int leftcount =  getKLevelNodeCount(root.left,k-1);
        int rightcount =  getKLevelNodeCount(root.right,k-1);
        return rightcount +leftcount ;
    }
    //求树的高度
    //子问题思路，求每一个子树max（左子树/右子树）高度，一个子节点高度为0/1
    public int getHight(TreeNode root){
        if (root == null){
            return 0;
        }
        //递归求子树高度
        int leftHight =  getHight(root.left);
        int righHight =  getHight(root.right);
        //当为空时，返回0，但实际高度为1，则加1
        return Math.max(leftHight+1,righHight+1) ;
    }
    //二叉树的最大深度
    //时间复杂度 O(n)   空间复杂度：O(树的高度)
    public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);

        return (leftHeight > rightHeight) ?
                (leftHeight+1):(rightHeight+1);
    }
    
     //检测值为value的元素是否存在，返回地址
    TreeNode find(TreeNode root, int val) {
        if(root == null) {
            return null;
        }
        if(root.val == val) {
            return root;
        }
        //leftTree代表整个左边，为空时结束此行代码（递归），进行右边
        TreeNode leftTree = find(root.left,val);
        //判断最后左边是否有返回值
        if(leftTree != null) {
            return leftTree;
        }
        //代表整个右边
        TreeNode rightTree = find(root.right,val);
        if(rightTree != null) {
            return rightTree;
        }
        return null;//没有找到
    }
   }