【数据结构】二叉树

目录

一、树

1.1树的一些重要概念

1.2树的应用

二、二叉树

2.1概念

2.2两种特殊的二叉树 

 二叉树的第一个特点

二叉树的第二个特点

二叉树的第三个特点

2.3二叉树的存储

2.4二叉树的遍历-深度优先搜索（二叉树的高度）dfs

前序遍历

中序遍历

后序遍历

2.5二叉树的遍历-广度优先搜索（二叉树的宽度）bfs

2.6二叉树的方法实现

（1）二叉树的结点个数

（2）二叉树的叶子结点个数

（3）二叉树的高度

（4）求第K层的结点个数

 （5）判断二叉树中是否存在指定值的元素

三、二叉搜索树

---

栈：树形结构的dfs（深度优先遍历-前中后序）

队列：树形结构的bfs（广度优先遍历-层序遍历）

一、树

编程世界中的树其实可以看做是一个道理生长的树，并且子树之间不能相交，若相交，不是树结构。子树的树根是否有多个父节点，若存在多个父节点，说明该子树存在相交，该结构也不是树。

 上述三个都不是树。

（1）树是不相交的。

（2）除了根节点外，每个节点有且仅有一个父节点。

（3）一颗N个结点得数拥有N-1条边。

1.1树的一些重要概念

 如图这是一个树。

结点的度：一个结点含有直接子树的个数称为该结点的度； 如上图：A的度为6 。

树的度：一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6 ，上图可以称为六叉树。

叶子结点或终端结点：度为0的结点称为叶结点； 如上图：B、C、H、I...等节点为叶结点 。

双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点，即度不为0就是双亲或者父结点。

孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点，只要是父节点下方的结点都属于该结点的子结点，H也是A的子节点。 

根结点：一棵树中，没有双亲结点的结点；如上图：A

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推 。

树的高度或深度：树中结点的最大层次； 如上图：树的高度为4 。

树的以下概念只需了解。

非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等节点为分支结点

兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点

堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为兄弟结点

结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先

子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙

森林：由m（m>=0）棵互不相交的树组成的集合称为森林。

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，实际中树有很多种表示方式，如：双亲表示法、孩子表示法、孩子双亲表示法、孩子兄弟表示法等等。我们最常用的孩子兄弟表示法。

1.2树的应用

看到树的结构就是天然高效进行查找（搜索）的结构。

现实生活中，任何一个企业/学校、人力组织都是一个天然的树结构，操作系统的文件管理也使用树结构。

二、二叉树

2.1概念

一棵二叉树中，结点的度最大为2，在二叉树中结点得度<=2。只有三种情况，度为0的结点-叶子结点，度为1的结点和度为2的结点。

二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树。

注意：以Node为跟的二叉树都存在以下几种情况。

2.2两种特殊的二叉树 

（1） 满二叉树：当前这棵树中，每一层节点都达到最大值的二叉树。每一层孩子都拉满，除了叶子结点以外，所有父节点的度都为2，节点个数n和层数k的关系：n = 2^k -1。满二叉树代表了一棵高度为k的二叉树中最多的结点个数。

（2）教材中完全二叉树的定义：若一棵二叉树的节点编号和对应的满二叉树节点编号一一对应则该二叉树是一个完全二叉树。

所谓的完全二叉树就是对应的满二叉树“缺了一个右下角”，其他的结点都完全靠左排列。

再定义：完全二叉树可以看做两个结点，第一阶段：每个节点都是度为2的结点。第二阶段：当碰到第一个度为1的结点或度为0的结点开始，转为第二阶段，第二阶段中所有节点都是叶子节点（不包括转阶段结点）。所以度为1的结点只可能有一个或者没有。

结论：当完全二叉树是偶数个结点，则度为1的结点个数为1。当完全二叉树是奇数个结点，则度为1的结点个数为0。

 二叉树的第一个特点

关于完全二叉树编号问题：完全二叉树使用数组存储，关键就是整个编号之间的关系

（1）若根节点从1开始编号，则在当前完全二叉树中，若某个结点的编号为x，且该节点存在左右孩子结点，则孩子和父节点的编号存在以下关系：

做孩子的编号为2x，有孩子的编号为2x+1，若它存在其他的父节点，则父节点编号为x/2，只保留整数部分。

（2）若根节点从0开始编号，则在当前完全二叉树中，若某个结点的编号为x，且该节点存在左右孩子结点，则孩子和父节点的编号存在以下关系：

做孩子的编号为2x+1，有孩子的编号为2x，若它存在其他的父节点，则父节点编号（x-1）/2，只保留整数部分。

二叉树的第二个特点

结点和树的高度关系：

一个高度为k的二叉树中最多有2^k-1个结点（此时是一颗满二叉树）

结点所在的层数为x，则该层最多有2^（x-1）个结点。

二叉树的第三个特点

在任意的一个二叉树中，度为2的结点N2和度为0的结点N0，N2 = N0 - 1。

推导：在树种结点的个数 = 边长+1。在二叉树中，N2+N1+N0 = 2N2 +N1 +1，所以N2 = N0 - 1。

2.3二叉树的存储

任意的数据结构在计算机内部存储是都分为基于数组方式存储和基于引用方式的链式存储。

二叉树也分为顺序存储和链式存储，只有完全二叉树适合采用顺序存储。

二叉树的链式存储：左右孩子表示法。（最常使用的方法）

private static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(int val){
            this.val = val;
        }
    }

孩子双亲表示法->用在平衡树的定义中。（在平衡树中，任意一个子树，左右孩子的高度之差不超过1）

2.4二叉树的遍历-深度优先搜索（二叉树的高度）dfs

什么是对于一个数据结构的遍历：（遍历不仅仅指的是元素值的打印或输出）按照一定的规则，将该数据结构中所有元素访问一次，做到不重不漏。

对于线性数据结构链表数组来说，遍历非常容易，要么从前向后遍历要么从后向前遍历。

在非线性结构中，如二叉树，遍历的方式有很多，其实各式各样的树形问题最终都可以看做是如何进行该树的遍历问题。采用不同的遍历方式，得到的结果会完全不同。

用左右孩子表示法来创建一个如图的二叉树。

public class BinTree {
    private static class TreeNode{
        char val;
        TreeNode left;
        TreeNode right;
        public TreeNode(char val){
            this.val = val;
        }
    }
    public TreeNode build(){
        TreeNode node1 = new TreeNode('A');
        TreeNode node2 = new TreeNode('B');
        TreeNode node3 = new TreeNode('C');
        TreeNode node4 = new TreeNode('D');
        TreeNode node5 = new TreeNode('E');
        TreeNode node6 = new TreeNode('F');
        TreeNode node7 = new TreeNode('G');
        TreeNode node8 = new TreeNode('H');
        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;
        node5.right = node8;
        return node1;
    }
}

前序遍历

（这里的序指的是根结点什么时候访问）

先访问树根节点，然后递归的访问左子树，再递归的访问右子树。

 则上图前序遍历结果是ABDEHCFG。

前序遍历位于即将开始访问一棵树的时候。

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

    public static void main(String[] args) {
        BinTree tree = new BinTree();
        TreeNode root = tree.build();
        System.out.println("前序遍历结果为 : ");
        tree.preOrder(root);
    }

中序遍历

先递归的访问左子树然后访问树根节点，最后递归的访问右子树。

则上图中序遍历结果是DBEHAFCG。

中序遍历左子树刚刚开始访问结束，马上开始右子树的访问时候。

    public void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

    public static void main(String[] args) {
        BinTree tree = new BinTree();
        TreeNode root = tree.build();
        System.out.println("中序遍历结果为 : ");
        tree.inOrder(root);
    }

后序遍历

先递归的访问左子树，再递归的访问右子树最后访问树根节点。

则上图后序遍历结果是DHEBFGCA。

后序遍历的结果为整棵树的树根节点，记过倒置就得到前序遍历的镜像结果即跟右左。

后序遍历位于即将离开一棵树的时候。

    public void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

    public static void main(String[] args) {
        BinTree tree = new BinTree();
        TreeNode root = tree.build();
        System.out.println("后序遍历的结果为 : ");
        tree.postOrder(root);
    }

 给定任意两个遍历结果必须有中序才能确定一棵二叉树。

2.5二叉树的遍历-广度优先搜索（二叉树的宽度）bfs

层序遍历：就是从二叉树的树根开始不断地从上至下，从左至右。

遍历的结果就是ABCDEFGH。

层序遍历的实现需要借助队列结构，先将根节点入队，依次将左右子树入队，出队顺序就是从上至下，从左至右。

然后创建一个list用来存储每一层的值，如何判断每一层有多少个值，就取决于当前队列的size。

然后进入while循环，当size>0，循环都可以继续进行，先出队并且存储起来，如果它的左子树和右子树都是非空的，那么就让他们依照左右顺序入队。

 然后继续进入循环中，依次进行入队出队操作，以及线性表list和lists的添加操作。

 所以整个外层循环的终止条件就是queue为空，如果为空则直接返回lists。

    public List> levelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List> lists = new ArrayList<>();
        Queue queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            List list = new ArrayList<>();
            int size = queue.size();
            while (size > 0) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
                size--;
            }
            lists.add(list);
        }
        return lists;
    }

2.6二叉树的方法实现

（1）二叉树的结点个数

需要将问题拆解，拆解成左右子树问题+当前树根的问题。

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

（2）二叉树的叶子结点个数

同样需要将问题拆解，拆解成左右子树问题+当前树根的问题。当root本身就是空，那么就没有叶子结点直接返回0，如果有跟结点并且它的左右孩子结点都为空那么就增加一个叶子结点，仍然用递归实现。

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

（3）二叉树的高度

 当前只知道root的情况，如果root为空那么就是0层，如果root！=null那么树根就是第一层，求出左右子树的高度之后去他俩最大值+1即可。

    public int height(TreeNode root){
        if(root==null){
            return 0;
        }
        return 1+Math.max(height(root.left),height(root.right));
    }

（4）求第K层的结点个数

排除非法情况后，整个遍历的终止条件就是k==1，这时就是要找的哪一层，然后对左右节点进行遍历。

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

 （5）判断二叉树中是否存在指定值的元素

首先排除二叉树为空的情况，这种情况一定不存在指定值的元素，然后遍历的终止条件就是当前结点得值和指定值相同，然后遍历左右结点。

public boolean contains(TreeNode root,char val){
        if(root==null){
            return false;
        }
        if(root.val==val){
            return true;
        }
        return contains(root.left,val)||contains(root.right,val);
    }

三、二叉搜索树

二叉/二分搜索树（二叉查找树）BST一般不存在重复结点（JDK的搜索树实现也不保存重复结点）

左子树的所有结果<跟结点<右子树的所有结果。

在二叉树中搜索一个特定的值，其实就是在进行二分查找，将不断和树根进行比较，知到到底在左子树中还是右子树中继续查找，O(logn)=>树的树高。

二分搜索树的中序遍历结果集一定是升序序列（辅助来判断一棵树是否满足搜索树的定义）