数据结构——树&二叉树

一、树

（1）树的定义:

• 树（Tree）: n（n≥0）个结点构成的有限集合

  • 当n=0时，称为空树

  • 对于任一棵非空树（n> 0），它具备以下性质：

  • 树中有一个称为“根（Root）”的特殊结点，用 root 表示；

  • 其余结点可分为m(m>0)个互不相交的有限集T1，T2，... ，Tm，其中每个集合本身又是一棵树，称为原来树的“子树（SubTree）”

注意:

• 子树之间不可以相交

• 除了根结点外，每个结点有且仅有一个父结点

• 一棵N个结点的树有N-1条边

（2）树的结构

 

（3）树的优点：

        树结构、数组和链表的对比

• 数组:

  • 优点:

    • 数组的主要优点是根据下标值访问效率会很高.

    • 根据元素来查找对应的位置时先对数组进行排序, 再进行二分查找

  • 缺点:

    • 需要先对数组进行排序, 生成有序数组, 才能提高查找效率.

    • 另外数组在插入和删除数据时, 需要有大量的位移操作(插入到首位或者中间位置的时候), 效率很低.

• 链表:

  • 优点:

    • 链表的插入和删除操作效率都很高.

  • 缺点:

    • 查找效率很低, 需要从头开始依次访问链表中的每个数据项, 直到找到.

    • 而且即使插入和删除操作效率很高, 但是如果要插入和删除中间位置的数据, 还是需要重头先找到对应的数据.

• 树结构:

  • 不能说树结构比其他结构都要好, 因为每种数据结构都有自己特定的应用场景.

  • 但是树确实也综合了上面的数据结构的优点(当然优点不足于盖过其他数据结构), 并且也弥补了上面数据结构的缺点.

  • 而且为了模拟某些场景,使用树结构会更加方便. 比如文件的目录结构.

（4）树的术语:

1. 结点的度（Degree）：结点的子树个数

2. 树的度：树的所有结点中最大的度数. (树的度通常为结点的个数N-1)

3. 叶结点（Leaf）：度为0的结点. (也称为叶子结点)

4. 父结点（Parent）：有子树的结点是其子树的根结点的父结点

5. 子结点（Child）：若A结点是B结点的父结点，则称B结点是A结点的子结点(也称孩子结点)

6. 兄弟结点（Sibling）：具有同一父结点的各结点彼此是兄弟结点

7. 路径和路径长度：从结点n1到nk的路径为一个结点序列n1 , n2,… , nk, ni是 ni+1的父结点，路径所包含边的个数为路径的长度

8. 结点的层次（Level）：规定根结点在1层，其它任一结点的层数是其父结点的层数加1

9. 树的深度（Depth）：树中所有结点中的最大层次是这棵树的深度

二、二叉树

1）概念

• 树中每个节点最多只能有两个子节点, 这样的树就成为"二叉树"

   二叉树的定义

• 二叉树可以为空, 即没有结点

• 不为空时它是由根结点和称为其左子树TL和右子树TR的两个不相交的二叉树组成

   二叉树的五种形态

注：c和d是不同的二叉树, 因为二叉树有左右之分

2）二叉树的特性

• 一个二叉树第 i 层的最大结点数为：2^(i-1), i >= 1

• 深度为k的二叉树有最大结点总数为： 2^k - 1, k >= 1

• 对任何非空二叉树 T，若n0表示叶结点的个数、n2是度为2的非叶结点个数，那么两者满足关系n0 = n2 + 1

3）特殊的二叉树

• 完美二叉树(Perfect Binary Tree) , 也称为满二叉树(Full Binary Tree）

  • 在二叉树中, 除了最下一层的叶结点外, 每层节点都有2个子结点, 就构成了满二叉树

• 完全二叉树(Complete Binary Tree)

  • 除二叉树最后一层外, 其他各层的节点数都达到最大个数

  • 且最后一层从左向右的叶结点连续存在, 只缺右侧若干节点

  • 完美二叉树是特殊的完全二叉树

• 下面不是完全二叉树, 因为D节点还没有右结点, 但是E节点就有了左右节点

4）二叉树的存储

• 二叉树的存储常见的方式是使用链表存储.

• 链表存储:

  • 每个结点封装成一个Node, Node中包含存储的数据, 左结点的引用, 右结点的引用.

三、二叉搜索树

1）概念

• 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树

• 二叉搜索树是一颗二叉树, 可以为空

• 如果不为空，满足以下性质：

  • 非空左子树的所有键值小于其根结点的键值

  • 非空右子树的所有键值大于其根结点的键值

  • 左、右子树本身也都是二叉搜索树

2）特点

• 二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上

• 查找效率非常高, 这也是二叉搜索树中, 搜索的来源

四、程序实现二叉搜索树

1）创建二叉搜索树类

//节点类
class Node {
            constructor(data) {
                this.left = null
                this.data = data
                this.right = null
            }
        }
//二叉搜索树类
class BST {
            constructor() {
                this.root = null
            }
}

2）二叉搜索树的操作

二叉搜索树常见的操作：

• insert(key)：向树中插入一个新的键

• search(key)：在树中查找一个键，如果结点存在，则返回true；如果不存在，则返回false

• preOrderTraverse：通过先序遍历方式遍历所有结点

• inOrderTraverse：通过中序遍历方式遍历所有结点

• postOrderTraverse：通过后序遍历方式遍历所有结点

• min：返回树中最小的值/键

• max：返回树中最大的值/键

• remove(key)：从树中移除某个键

（1） 向树中插入数据

insert(ele) {
                //创建新节点
                let newnode = new Node(ele)
                if (this.root == null) {
                    //空树
                    this.root = newnode
                } else {
                    this.insertNode(this.root, newnode)
                }

            }

insertNode(root, newnode) {
                if (newnode.data < root.data) { //放左边
                    if (root.left == null) {
                        root.left = newnode
                    } else {
                        this.insertNode(root.left, newnode)
                    }
                }else{ //放右边
                    if (root.right == null) {
                        root.right = newnode
                    } else {
                        this.insertNode(root.right, newnode)
                    }
                }
            }

 图示：

（2）遍历二叉搜索树

（1）preOrderTraverse：通过先序遍历方式遍历所有结点

遍历过程：

1. 访问根结点
2. 先序遍历其左子树
3. 先序遍历其右子树

preOrderTraversal(){
                this.preOrderTraversalNode(this.root)
            }

            preOrderTraversalNode(root){
                if(root!=null){
                    //1.根
                    console.log(root.data)
                    //2.前序遍历左子树
                    this.preOrderTraversalNode(root.left)
                    //3.前序遍历右子树
                    this.preOrderTraversalNode(root.right)
                }
            }

（2）inOrderTraverse：通过中序遍历方式遍历所有结点

遍历过程:

1. 中序遍历其左子树

2. 访问根结点

3. 中序遍历其右子树

inOrderTraversal(){
                this.inOrderTraversalNode(this.root)
            }

            inOrderTraversalNode(root){
                if(root!=null){
                    //1.中序遍历左子树
                    this.inOrderTraversalNode(root.left)
                    //2.根
                    console.log(root.data)
                    //3.中序遍历右子树
                    this.inOrderTraversalNode(root.right)
                }
            }

（3）postOrderTraverse：通过后序遍历方式遍历所有结点

遍历过程：

1. 后序遍历其左子树

2. 后序遍历其右子树

3. 访问根结点

postOrderTraversal(){
                this.postOrderTraversalNode(this.root)
            }

            postOrderTraversalNode(root){
                if(root!=null){
                    //1.后序遍历左子树
                    this.postOrderTraversalNode(root.left)
                    //2.中序遍历右子树
                    this.postOrderTraversalNode(root.right)
                    //3.根
                    console.log(root.data)
                    
                }
            }