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)