javascript 数据结构与算法---二叉数

二叉树，首先了解一些关于二叉数的概念(来自百度百科)

1. 二叉树（Binary tree）是树形结构的一个重要类型

2. 定义: 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树

3. 二叉树可以分为: （1.）空二叉树  ;（2.） 只有一个根结点的二叉树 ; （3. ） 只有左子树 ；（4.）只有右子树，（5.）完全二叉树; （6.）满二叉树

4.  相关术语

①结点：包含一个数据元素及若干指向子树分支的信息 

②结点的度：一个结点拥有子树的数目称为结点的度

③叶子结点：也称为终端结点，没有子树的结点或者度为零的结点 

④分支结点：也称为非终端结点，度不为零的结点称为非终端结点 

⑤树的度：树中所有结点的度的最大值 

⑥结点的层次：从根结点开始，假设根结点为第1层，根结点的子节点为第2层，依此类推，如果某一个结点位于第L层，则其子节点位于第L+1层 

⑦树的深度：也称为树的高度，树中所有结点的层次最大值称为树的深度

 

相关概念了解后，我们使用ts 来写一个二叉数

 

一、声明一个节点的数据结构接口

type INodeTree<T> = {
    value: T;
    left: INodeTree<T>|null;
    right: INodeTree<T>|null;
}

二、 实现一个节点类

//实现节点对象
class TNode<T>{
    public value:T
    public left:INodeTree<T>|null;
    public right:INodeTree<T>|null;
    constructor(data:T){
        this.value = data
        this.left = null
        this.right = null
    }
}

三、实现一个二叉数类

1. 进行二叉排序

2. 前序遍历：

3. 中序遍历

4. 后续遍历

5. 层次遍历

6. 找最大值

7. 找最小值

 class BinaryTree<T>{
     private data:T[]
     private rootNode:INodeTree<T>
     /**
      *
      * @param data
      */
     constructor(data:T[]){
         if(!Array.isArray(data)||data.length<1){
             throw("参数必须为数组且数组长度不能少于1")
         }
         this.data = data
         this.rootNode = new TNode(data[0]);////初始化根节点

     }
     /**
      * 二叉排序
      *  1. 先判断当前节点node的值 与入排的值key 比大小，小进左，大近右,相等的话默认进右边
      *  2. 然后判断是否存在子节点，如果存在,递归比较，否侧，就进排
      */
     public sortNode():INodeTree<T>{
         let handleSortNode = (node:INodeTree<T>,key:T)=>{
             // 对比大小
             if(node.value>key){

                 //判断是否存在左子节点
                 if(node.left===null){
                     if(key){
                         node.left = new TNode(key)
                     }

                 }else{
                     handleSortNode(node.left,key)
                 }

             }else{
                  //右边同理
                  if(node.right==null){
                     if(key){
                         node.right = new TNode(key)
                     }

                 }else{
                     handleSortNode(node.right,key)
                 }
             }
         }
         for(let i =1;i<this.data.length;i++){
             handleSortNode(this.rootNode,this.data[i])
         }
         return this.rootNode
     }

     /**
      * 中序遍历:从根节点开始遍历，从左向右开始访问，根节点值在中间；简单理解就是： 左子树->父节点->右子树
      */
     public orderSortNode():Array<T>{
         let res:T[] = [];
         let orderRraverNode = function(node:INodeTree<T>|null){
             if(!node) return
             orderRraverNode(node.left)
             res.push(node.value)
             orderRraverNode(node.right)

         }
         orderRraverNode(this.rootNode)
         return res
     }
     /**
      * 前序遍历：从根节点开始遍历，从左向右开始访问，最先输出根节点值；简单理解就是： 父节点->左子树->右子树
      */
     public beforeSortNode():Array<T> {
         let res:T[] = [];
         let beforeRraverNode = function(node:INodeTree<T>|null){
             if(!node) return
             res.push(node.value)
             beforeRraverNode(node.left)
             beforeRraverNode(node.right)

         }
         beforeRraverNode(this.rootNode)
         return res
     }

     /**
      * 后序遍历：从根节点开始遍历，从左向右开始访问，最后才输出根节点值；简单理解就是： 左子树->右子树->父节点
      */
     public afterSortNode() {
         let res:T[] = [];
         let afterRraverNode = function(node:INodeTree<T>|null){
             if(!node) return
             afterRraverNode(node.left)
             afterRraverNode(node.right)
             res.push(node.value)

         }
         afterRraverNode(this.rootNode)

         return res
     }

     /**
      * 层次遍历：按照树的层次自上而下的遍历二叉树；利用队列实现
      */
     public levelSortNode():T[]{
         let queue = [this.rootNode];//直接根节点入队
         let res:T[] = []
         while(queue.length>0){
             let node = queue.shift();//出队
             if(node){
                 res.push(node.value)
                 if(node.left){
                     queue.push(node.left);//入队
                 }
                 if(node.right){
                     queue.push(node.right);//入队
                 }
             }
         }
         return res
     }

     /**
      * 找最小值，其实就是递归左子节点
      */
     public minNodeValue():T {

         let res:T = this.rootNode.value;
         let minNode = this.rootNode.left
         while(minNode&&minNode.left){
             minNode = minNode.left;
             res = minNode.value
         }
         return res
     }

     /**
      * 找最小值，其实就是递归右子节点
      */
     public maxNodeValue():T {
         let res:T = this.rootNode.value;
         let maxNode = this.rootNode.right
         while(maxNode&&maxNode.right){
             maxNode = maxNode.right;
             res = maxNode.value
         }
         return res
     }
 }

4. 创建一个工厂函数(可省略)

function createBinaryTree<T>(data:T[]){
    return new BinaryTree(data)
}

5. 调用示例　

// let arr = [10,5,1,3,8,4,2,12,17,11,14,12,20]
let arr = ['C', 'B', 'E', 'A',"H",'D']
let res = createBinaryTree(arr)
// 二叉排序
let resSort = res.sortNode()
console.log(resSort)

// 中序遍历
let resO = res.orderSortNode()
console.log("resO",resO)

// 前序遍历
let resB = res.beforeSortNode()
console.log("resB",resB)

// 后序遍历
let resF = res.afterSortNode()
console.log("resF",resF)

// 层次遍历
let resL = res.levelSortNode()
console.log("resL",resL)

// 最小值
let resMin = res.minNodeValue()
console.log(resMin)

//最大值
let resMax= res.maxNodeValue()
console.log(resMax)