二叉树算法

简介

大家都知道面试时考官必考二叉树，二叉树又是什么呢，表面上看二叉树不就是一棵树嘛，树有树根，主干，分子，树叶，而计算机的二叉树却是倒着长的，看图就明白了

排序方式

二叉树有三种排序方式，分别是前序，中序，后序，以上面的例子

1. 前序：首先访问根节点=>     1,2,4,5,8,3,6,7,9
2. 中序：中间访问根节点=>     4,2,5,8,1,6,3,9,7
3. 后序：最后访问根节点=>     4,8,5,2,6,9,7,3,1

模拟二叉树排序

            class node{
                constructor(data,left,right){
                    this.data = data
                    this.left = null
                    this.right = null
                }
            }
            function setTree(){ 
                var arr = []
                var root = new node(1) 
                for(var i = 0; i < 7; i++){
                   arr.push(new node(i+2))
                }
                root.left = arr[0]
                root.right = arr[1]
                arr[0].left = arr[2]
                arr[0].right = arr[3]
                arr[1].left = arr[4]
                arr[1].right = arr[5]
                return root
            }
            setTree()
            function pre(node){
                if(!node){
                    return 
                }
                //console.log(node.data) --前序
                pre(node.left)
                //console.log(node.data) --中序
                pre(node.right)
                //console.log(node.data) --后序
            }
            pre(setTree())

若给出一个二叉树任意两个序列，列如前序和中序，或者后序和中序，问你还原这棵树，这时就需要封装函数了

前序，中序

            var pre = [1,2,4,5,8,3,6,7,9]
            var mid = [4,2,5,8,1,6,3,9,7]
            function preMid(pre,mid){
                if(pre.length==0 || mid.length == 0){
                    return
                }
                if(pre.length !== mid.length){
                    throw Error('参数不正确')
                }
                var rootData = pre[0] //根节点数据
                var midRootIndex = mid.indexOf(rootData) //中序根节点index值
                var leftMid = mid.slice(0,midRootIndex) //左子树中序遍历
                var rightMid = mid.slice(midRootIndex+1) //右子树中序遍历
                var leftPre = pre.slice(1,leftMid.length+1) //左子树前序遍历
                var rightPre = pre.slice(leftMid.length+1)  //右子树前序遍历
                var left = preMid(leftPre,leftMid) // 左子树还原
                var right = preMid(rightPre,rightMid) //右子树还原
                var node = new Node(pre[0],left,right) //二叉树
                return node
            }
            preMid(pre,mid)

后序，中序

            var aft = [4,8,5,2,6,9,7,3,1]
            var mid = [4,2,5,8,1,6,3,9,7]
            function aftMid(aft,mid){
                var len = aft.length
                if(aft.length==0 || mid.length == 0){
                    return
                }
                if(aft.length !== mid.length){
                    throw Error('参数不正确')
                }
                var rootData = aft[len-1]
                var midRootIndex = mid.indexOf(rootData)
                var leftMid = mid.slice(0,midRootIndex) //左子树前序遍历
                var rightMid = mid.slice(midRootIndex+1) //右子树前序遍历
                var leftAft = aft.slice(0,leftMid.length) //左子树后序遍历
                var rightAft = aft.slice(leftMid.length,aft.length-1) //右子树后序遍历
                var left = aftMid(leftAft,leftMid) //左子树还原
                var right = aftMid(rightAft,rightMid) //右子树还原
                var node = new Node(aft[len-1],left,right) //二叉树
                return node
            }
            aftMid(aft,mid)