JS数据结构第五篇 --- 二叉树和二叉查找树

一、二叉树的基本概念

从逻辑结构角度来看,前面说的链表、栈、队列都是线性结构;而今天要了解的“二叉树”属于树形结构。

1.1 多叉树的基本概念,以上图中“多叉树”为例说明

  节点:多叉树中的每一个点都叫节点;其中最上面的那个节点叫“根节点”;

  父节点:节点1是节点2/3/4/5/6的父节点,然后节点2/3/4/5/6是节点1的子节点;节点2/3/4/5/6又是互为兄弟节点,因为它们有父节点为同一个节点;

  空树:一个没有任何节点的树叫空树;一棵树可以只有一个节点,也就是只有根节点;

  子树:子节点及子节点的后台节点形成的一个节点集合叫子树;对于只有两个子节点的节点,其左边的子节点叫左子树,右边的叫右子树;

  叶子节点(leaf):子树为0的节点;其他子树不为0的节点叫“非叶子节点”;

  层数(level):根节点在第1层,根节点的子节点在第2层,以此类推(有些说法也从第0层开始结算);

  节点的深度(depth):从根节点到当前节点的唯一路径上的节点总数;

  节点的高度(height):从当前节点到最远叶子节点的路径上的节点总数;

  树的深度:所有节点深度中的最大值;

  树的高度:所以节点高度中的最大值;数的深度等于数的高度

  有序树:树中任意节点的子节点之间有顺序关系;

  无序树:树中任意节点的子节点之间没有顺序关系,也叫“自由树”;

  森林:由n(n >= 0) 颗不相交的树组成的集合;

1.2 二叉树的特点

  • 每个节点的度最大为2(最多拥有2颗子树);
  • 左子树和右子树是有顺序的。即使某节点只有一颗子树,也要区分左右子树;
  • 非空二叉树的第i层,最多有2^(i-1)个节点(i >= 1)
  • 在高度为h的二叉树上最多有2^h - 1个节点(h >= 1);
  • 对于任何一颗非空二叉树,如果叶子节点个数为n0, 度为2的节点个数为n2, 则有n0 = n2 + 1。(这个好理解,假如这个二叉树除了第一级节点有2个子节点,后面的节点都是只有一个子节点,则不管这颗二叉树如何往下延伸,永远度为2的节点个数是1个,叶子节点为2个;然后如果在这个二叉树的中间节点,每加一个节点,相当于度为2的节点加一个,叶子节点也加一个,则度为2的节点和叶子节点的增加是同步同数量的,所以对于二叉树,叶子节点个数 = 度为2的节点个数 + 1 公式是永远成立的)
  • 假设度为1的节点个数为n1, 那么二叉树的节点总数 n = n0 + n1 + n2。则二叉树的边数T = n1 + 2 * n2 = n -1 = n0 + n1 + n2 -1  --> n2 + 1 = n0

1.3 真二叉树/满二叉树/完全二叉树

  • 真二叉树:所有节点的度都要么为2,要么为0;
  • 满二叉树:所有节点的度都要么为2,要么为0,且所有的叶子节点都在最后一层;
    • 假设满二叉树的高度为h (h>=1),那么第i层的节点数量:2^(i-1), 叶子节点数量:2(^h-1), 总节点数量n = 2^h -1 = 2^0 + 2^1 + 2^2 + ... + 2^(h-1)
    • 等比数列公式:a1=1, 公比q=2, 则an = a1*q^(n-1)=2^(n-1), 前n项之和Sn = a1+a2+...+an = 2^0 + 2^1 + 2^2 + ... + 2^(n-1) = a1(1-q^n)/(1-q)=2^n-1
    • 在同样高度的二叉树中,满二叉树的叶子节点数量最多、总节点数量最多;
    • 满二叉树一定是真二叉树,真二叉树不一定是满二叉树;
  • 完全二叉树:叶子节点只会出现在最后两层,且最后一层的叶子节点都靠左对齐;
    • 完全二叉树从根节点到倒数第二层是一颗满二叉树;满二叉一定是完全二叉树,完全二叉树不一定是满二叉树;
    • 度为1的节点只有左子树;度为1的节点要么是1个,要么是0个;
    • 假设完全二叉树的高度为h(h>=1), 那么至少有2^(h-1) 个节点(2^0 + 2^1 + 2^2 + ... + 2^(h-2) + 1), 最多有2^h - 1个节点(2^0 + 2^1 + 2^2 + ...+ 2^(h-1), 满二叉树);总节点数量为n, 则有2^(h-1) <= n < 2^h  -->  h-1 <= log(2)(n) < h --> h = floor(log(2)(n)) + 1  (floor是向下取整,ceiling是向上取整)
    • 一颗有n个节点的完全二叉树(n > 0),从上到下,从左到右对节点从1开始进行编号,对任意第i个节点
      • 如果i = 1, 它是根节点
      • 如果i > 1, 它的父节点编号为floor(i/2)
      • 如果2i <= n, 它的左子节点编号为2i
      • 如果2i > n, 它无左子节点
      • 如果2i + 1 <= n, 它的右子节点编号为2i + 1
      • 如果2i + 1 > n , 它无右子节点  

   

面试题:如果一颗完全二叉树有768个节点,求叶子节点的个数?

分析:假设叶子节点个数为n0,度为1的节点个数为n1,度为2的节点个数为n2。

  则总节点个数n = n0  +  n1 +  n2,而且n0 = n2 + 1 ;

  则n = 2n0 + n1 -1

  根据完全二叉树的定义我们知道,n1要么为0,要么为1:

  当n1为1时, n = 2n0,  n必然为偶数。叶子节点个数n0 = n / 2,非叶子节点个数 n1 + n2 = n / 2 ;

  当n1为0,n = 2n0 - 1,n必然为奇数。叶子节点个数n0 = (n + 1) / 2, 非叶子节点个数 n1 + n2 = (n - 1) / 2

  因此可以判断出来当这个完全二叉树有768个节点时,它的叶子节点个数为:384

 

二、二叉查找树

二叉查找树是一种特殊的二叉树,较小的值保存在左节点中,较大的值保存在右节点中。这一特性使得查找的效率很高,对于数值型和非数值型的数据,如单词和字符串,都是如此。

2.1 二叉查找树的插入逻辑

  2.1.1 设根节点为当前节点

  2.1.2 如果待插入节点保存的数据小于当前节点,则设新的当前节点为原节点的左节点;反之,执行第2.1.4步

  2.1.3 如果当前节点的左节点为null, 就将新的节点插入这个位置,退出循环;反之,继续执行下一次循环

  2.1.4 设新的当前节点为原节点的右节点

  2.1.5 如果当前节点的右节点为null, 就将新的节点插入这个位置,退出循环;反之,继续执行下一次循环

//插入元素
    function insertBST(element){
        var node = new Node(element, null, null);

        //根节点判断
        if (root == null){
            root = node;
        }
        else{ //非根节点
            var current = root;
            while(true){
                if (element < current.element){ //往左节点方向放
                    if (current.left == null){
                        current.left = node;
                        break;
                    }
                    current = current.left;
                }
                else if (element > current.element){ //往右节点方向放
                    if (current.right == null){
                        current.right = node;
                        break;
                    }
                    current = current.right;
                }
                else { //相等,替换
                    current.element = element;
                    return;
                }
            }
        }
        size++;
    }
View Code

2.2 二叉查找树的遍历,遍历有三种方式:中序、前序、后序

  中序指以升序的方式遍历所有节点;前序是指先访问根节点,再以同样的方式访问左子树和右子树;后序指的是先访问叶子节点,再从左子树到右子树,最后到根节点。

先看个效果图

遍历走势分析图:

遍历代码:

//二叉树中序遍历:以升序方式访问二叉树中所有节点
    function inOrder(){
        return inOrderByNode(root);
    }
    function inOrderByNode(node){
        if (node){
            var str = "";
            str += inOrderByNode(node.left);
            str += node.element + ", ";
            str += inOrderByNode(node.right);
            return str;
        }
        return "";
    }


    //前序遍历:先访问根节点,再访问左子树和右子树
    function preOrder(){
        return preOrderByNode(root);
    }
    function preOrderByNode(node){
        if (node){
            var str = '';
            str += node.element + ", "; //先访问根节点
            str += preOrderByNode(node.left); //再访问左子树
            str += preOrderByNode(node.right); //再访问右子树
            return str;
        }
        return "";
    }


    //后序遍历:先访问叶子节点,再左子树,再右子树,再到根节点
    function postOrder(){
        return postOrderByNode(root);
    }
    function postOrderByNode(node){
        if (node){
            var str = "";
            str += postOrderByNode(node.left);
            str += postOrderByNode(node.right);
            str += node.element + ", ";
            return str;
        }
        return "";
    }
View Code

四则运算的表达式可以分为三种:

  •  前缀表达式(prefix  expression),又称波兰表达式
  • 中缀表达式(infix  expression)
  • 后缀表达式(postfix  expression),又称为逆波兰式表达式

如果将表达式的操作作为叶子节点,运算符作为父节点(假设只有四则运算),这些节点刚好可以组成一颗二叉树。

比如表达式:A / B + C * D - E  ,如果对这颗二叉树进行遍历

  • 前序遍历:- + / A B * C D E ,刚好就是前缀表达式(波兰表达式)
  • 中序遍历:A / B + C * D - E,刚好就是中缀表达式
  • 后序遍历:A B / C D * + E -,刚好就是后缀表达式(逆波兰表达式)

 

2.3 查找二叉查找树的最大值、最小值、是否存在某个值

最大值:因为较大的值都是在右子树上,则最大值一定是在右子树的最后一个节点上;

最小值:较小的值都是在左子树上,则最小值一定在左子树的最后一个节点上;

是否存在某个值,则是遍历查找

//查找最小值:因为较小的值都在左边,所以最小值一定是左子树的最后一个节点
    function getMin(){
        var minNode = getMinNode(root);
        if (minNode) {
            return minNode.element;
        }
        return null;
    }
    //查找最小节点
    function getMinNode(node){
        var current = node;
        while(current){
            if (current.left == null){
                return current;
            }
            current = current.left;
        }
        return null;
    }

    //查找最大值:因为较大的值都在右边,所以最大值一定是在右子树的最后一个节点
    function getMax(){
        var maxNode = getMaxNode(root);
        if (maxNode){
            return maxNode.element;
        }
        return null;
    }
    //查找最大节点
    function getMaxNode(node){
        var current = node;
        while(current){
            if (current.right == null){
                return current;
            }
            current = current.right;
        }
        return null;
    }

    //查找指定值,是否存在这个元素
    function isExist(element){
        var current = root;
        while(current){
            if (element < current.element){ //左子树寻找
                current = current.left;
            }
            else if (element > current.element){ //右子树寻找
                current = current.right;
            }
            else{ //存在
                return true;
            }
        }
        return false;
    }
View Code

 

2.4 删除二叉查找树中的指定元素

从二叉查找树上删除节点的操作最复杂,其复杂程度取决于删除哪个节点。如果删除没有子节点 的节点,那么非常简单。如果节点只有一个子节点,不管是左子节点还是右子节点,就变 得稍微有点复杂了。删除包含两个子节点的节点最复杂。

//删除元素
    function remove(element){
        root = removeNode(root, element);
    }
    function removeNode(node, element){
        if (node == null) {
            return null;
        }

        if (node.element == element){
            size--;
            //node没有左子树
            if (node.left == null){
                return node.right;
            }
            else if (node.right == null){ //node没有右子树
                return node.left;
            }
            /**
             * node有左子树和右子树,这个时候要找出最接近node节点值的节点
             * 1、如果找出比node节点的element稍大的节点,则从node右节点的最小节点
             * 2、如果找出比node节点的element稍小的节点,则从node左节点的最大节点
             */
            //第一种方式,找出比node的element稍微大点的节点
            var minNode = getMinNode(node.right);
            node.element = minNode.element;
            node.right = removeNode(node.right, minNode.element);

            // //第二种方式, 找出比node的element稍微小点的节点
            // var maxNode = getMaxNode(node.left);
            // node.element = maxNode.element;
            // node.left = removeNode(node.left, maxNode.element);

            return node;
        }
        else if(element < node.element){ //往左子树方向继续找
            node.left = removeNode(node.left, element);
            return node;
        }
        else{
            //往右子树方向继续找
            node.right = removeNode(node.right, element);
            return node;
        }
    }
View Code

 

完整demo见:https://github.com/xiaotanit/Tan_DataStruct

posted @ 2019-08-19 00:51 TDX 阅读(...) 评论(...) 编辑 收藏