数据结构之树型结构

相关概念

重点概念：后续学习将会反反复复出现

对我们当前学习稍微不重要：

树的表示

树有很多种表示方式，如：双亲表示法，孩子表示法、孩子双亲表示法（AVL树、红黑树、B树会用到）、孩子兄弟表示法等等。我们了解一下孩子兄弟表示法：

代码表示：

class Node{
	int value;//我们当前学习就是简简单单的存个int数字
	Node firstChild;
	Node nextNorther;

}

二叉树

二叉树：每一个节点的度小于等于2；其实就是每一个节点的孩子个数不超过两个。二叉树的有次序是指你把右子树放左边画出来，结果就是两个不同的树
任意二叉树都是由以下的情况组合的：

满二叉树：每层的结点数都达到最大值；如果层数是k；满二叉树的节点个数为2^k-1

完全二叉树：你按左右到上下编号1-n一定是连续的

二叉树性质

前提：规定第一层是根节点的二叉树
1：第i层最多节点个数：2^(i-1)
2：深度为k；总节点个数最多是2^k-1 (完全二叉树的情况)

3：非常重要；任意的二叉树；叶子节点个数比度为2的节点个数多一个（度为0就是叶子，不涉及到度为1的节点）
n0=n2+1 （如果要把n1也扯上关系；使用n-1=n00+n11+n2*2；n是总节点个数；解释：一颗n个节点的树有N-1条边；而叶子节点不产生边；度为1的节点只产生一条边；度为2的节点产生两条边）
比如有4层：
其实就是；2的4次方等于2的3次方+2都平方+2的1次方+2的0次方+1。
题目：
某二叉树共有399个结点，其中有199个度为2的结点，则该二叉树中的叶子结点数为（）
A不存在这样的二叉树
B200
C198
D199

4：具有n个结点的完全二叉树的深度k为log(n+1)向上取整
不受到你最后层节点个数影响，最后层一个跟2的n-1个是一样，因为用最大节点个数推导出来的
5：对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：
若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点若2i+1 若2i+2 注意：完全二叉树度为1的节点要么是1个，要么是0个。奇数个节点就没有度为1的节点，偶数个节点就有一个度为1的节点。如果题目告诉你2n个节点；那就说明有度为1的节点

二叉树储存

如何遍历：
先序：根—>左子树---->右子树(这个比较容易理解)
中序：左子树—>根—>右子树（先访问左子树，然后你左子树又得按照中序进行）
后序：左子树–>右子树—>根

实现一颗二叉树

创建

//创建一颗树
class  tree{
    //树的节点，还是内部类实现，类似链表
    class Listnode{
        //一个节点包含三个域
        char val;
        Listnode left;//左边
        Listnode right;//右边

        public Listnode(char val) {
            this.val = val;
        }
    }
    public Listnode create(){
        //先把节点和值创建好，然后再绑关系
        Listnode A=new Listnode('A');
        Listnode B=new Listnode('B');
        Listnode C=new Listnode('C');
        Listnode D=new Listnode('D');
        Listnode E=new Listnode('E');
        Listnode F=new Listnode('F');
        Listnode G=new Listnode('G');
        //这里的B和C是节点
        A.left=B;
        A.right=C;
        B.left=D;
        B.right=E;
        C.left=F;
        C.right=G;

        return A;//返回根节点
    }

遍历（前中后序）

前序：

   public void print1(Listnode root){
        if(root==null) {
            return ;
        }
        System.out.println(root.val);
        print1(root.left);
        print1(root.right);

    }

中序：这次我们就不打印；遍历把值存在顺序表里

    public List<Character> print2(Listnode root){
        List<Character> list=new ArrayList<>();
        if(root==null)
        {
            return list;
        }
        //System.out.println(root.val);
        list.add(root.val);
        print2(root.left);
        print2(root.right);
        return list;
    }

后序：

public List<Character> print3(Listnode root){
    List<Character> ret=new ArrayList<>();
    if(root==null)
    {
        return ret;
    }
    //System.out.println(root.val);
    ret.add(root.val);//先把头放进去，然后左边放一个表，右边放一个表，最后放到ret
    List<Character> s=print3(root.left);
               ret.addAll(s);
    List<Character> s1=print3(root.right);
    ret.addAll(s1);
    return ret;
}

获取树中节点个数

//获取树中节点的个数
    int num=0;
    public int size(Listnode root){
        //遍历计数器
        if(root==null) {
            return 0;
        }
        num++;
        size(root.left);
        size(root.right);
        return num;
    }
    //子问题计数
    public int size1(Listnode root){
        if(root==null) {
            return 0;
        }
        int tmp =size1(root.left)+size1(root.right)+1;//(把走到每个节点都分为左边、右边和它自己)
        return tmp;
    }

获取叶子节点个数

   // 获取叶子节点的个数
    int ret3=0;
     public  void getLeafNodeCount(Listnode root){
//自己为空，肯定就结束了
    if(root==null){
        return ;
    }
    //如果左边和右边同时为空就计数
         if(root.left==null&&root.right==null){
             ret3++;
         }
       getLeafNodeCount(root.left);
       getLeafNodeCount(root.right);

     }
    // 子问题思路-求叶子结点个数
    public  int getLeafNodeCount1(Listnode root){
//自己为空，肯定就结束了
        if(root==null){
            return 0;
        }
        //如果左边和右边同时为空就计数
        if(root.left==null&&root.right==null){
            return 1;
        }
        return getLeafNodeCount1(root.left)+getLeafNodeCount1(root.right);

    }

获取第k层节点个数

   // 获取第K层节点的个数,直接子问题
  public  int getKLevelNodeCount(Listnode root,int k){
//我们之前不是求了一棵树节点个数吗；假设我要求k层，在k-1的左右子树的和
	if(root==null||k<=0) {
	      return -1;
	}
	if(k==1){//这时候条件就不再是root.left==null&&root.right==null；而是k-1层的孩子节点我都要计算
	    return 1;
	}
	int tmp=getKLevelNodeCount(root.left,k-1)+getKLevelNodeCount(root.right,k-1);

	return tmp;
    }

获取二叉树高度

非常巧妙：递归的结束root==null；返回上一级到叶子节点；发现height1>height2不成立；叶子节点的右边+1；如果是root.left遍历下的就返回给这里的值。画个图就好理解

  // 获取二叉树的高度
    public int getHeight(Listnode root) {
        if(root==null){
            return 0;
        }
        int height1=  getHeight(root.left);
        int height2= getHeight(root.right);
        if (height1>height2){
            return height1+1;//加1是关键，每结束一层+1
        }
        else
            return height2+1;
    }

检测值为value元素是否存在

   // 检测值为value的元素是否存在
   public Listnode find(Listnode root, int val) {
       if (root == null) {
           return null;
       }
       if (root.val == val) {

           return root;
       }
       find(root.left, val);//这里应该把find(root.left,val)存到ret里，避免下面用这个又要重复再递归一次
       if (find(root.left, val).val == val) {
           return root;
       }     //如果我在左边找到就不去右边

       //如果我在右边找到就直接结束，如果都没找到
       find(root.right, val);
       if (find(root.right, val).val == val) {
           return root;
       }
       return null;

       
   }

层序遍历（需要队列来实现）

因为二叉树；没法按这种顺序来遍历；就得依靠别的数据结构

这样子它的打印顺序就是从左到右；画图分析好

判断是否为完全二叉树（需要队列来实现）

队列；逻辑：按层次遍历弹出，把Null也放入队列里，当弹出Null的时候发现队列全为Null，就说明是完全二叉树
。不全为null就不是完全二叉树。

   // 判断一棵树是不是完全二叉树   ，这题逻辑还是非常清晰
    public boolean isCompleteTree(TreeNode root) {
        if(root == null) {
            return true;
        }
        Queue<TreeNode> qu = new LinkedList<>();
        qu.offer(root);
        while (!qu.isEmpty()) {
            TreeNode cur = qu.poll();
            if(cur != null) {
                qu.offer(cur.left);
                qu.offer(cur.right);
            }else {
                break;
            }
        }
        //判断队列剩下的值 是否有 非null的数据
        while (!qu.isEmpty()) {
            TreeNode pop = qu.poll();
            if(pop != null) {
                return false;
            }
        }
        return true;
    }