node55先、中、后遍历

//先、中、后遍历
zhufengpeixun.com/jg-vue/node/tree.html

前序遍历    中、左、右
中序遍历    左、中、右
后序遍历    左、右、中

class Node{
    constructor(element,parent){  //parent是树中比较重要的属性
        this.element = element;
        this.parent = parent;
        this.left = null;
        this.right = null;
    }
}
class BST{  //不能通过索引取数据
    constructor(compare){
        this.root = null;
        this.size= 0;  //包含着的节点个数
        this.compare = compare||this.compare;
    }
    compare(e1,e2)
    {
        return e1 - e2;
    }
    add(element){
        if(this.root == null)
        {
            this.root = new Node(element,null);
            this.size++;
            return;
        }
        else
        {
            //增加的不是根节点，第一种方式是根据递归 写循环
            let currentNode = this.root;//当前的根节点
            let compare= 0;//当前比较的结果
            let parent = null;//当前父节点

            while(currentNode){
                compare= this.compare(element,currentNode.element);
                parent = currentNode;
                if(compare > 0)  //如果大于0就找右树，小于0找左树
                {
                    currentNode= currentNode.right;
                }
                else if(compare < 0)
                {
                    currentNode = currentNode.left;
                }
                else{
                    //break;不处理
                    currentNode.element = element; //如果比较后结果一样，就有最新的去覆盖
                    return;
                }
            };

            let newNode = new Node(element,parent);
            if(compare > 0)
            {
                parent.right = newNode;
            }
            else
            {
                parent.left = newNode;
            }
        }
    }
    preorderTraversal(){
        const travelsal = (node)=>{
            if(node == null)return;
            console.log(node.element);
            travelsal(node.left);
            travelsal(node.right);
        }
        travelsal(this.root);
    }
    inorderTraversal(){
        const travelsal=(node)=>{
            if(node == null)return;
            travelsal(node.left);
            console.log(node.element);
            travelsal(node.right);
        }
        travelsal(this.root);
    }
    postorderTraversal(){
        const travelsal=(node)=>{
            if(node == null)return;
            travelsal(node.left);
            travelsal(node.right);
            console.log(node.element);
        }
        travelsal(this.root);
    }

}

let bst = new BST((e1,e2)=>{ //arr.sort默认调用sort就是简单a-b 自定义比较器
    return e1.age-e2.age;
});
let arr=[{age:10,name:'zs'},{age:8},{age:19},{age:6},{age:15},{age:22},{age:20},{age:10,name:'lisi'}];
arr.forEach((element)=>{
    bst.add(element);
});
//console.dir(bst.root,{depth:200});
//bst.preorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 10, name: 'lisi' }
{ age: 8 }
{ age: 6 }
{ age: 19 }
{ age: 15 }
{ age: 22 }
{ age: 20 }
 */
//bst.inorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 6 }
{ age: 8 }
{ age: 10, name: 'lisi' }
{ age: 15 }
{ age: 19 }
{ age: 20 }
{ age: 22 }
 */
//bst.postorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 6 }
{ age: 8 }
{ age: 15 }
{ age: 20 }
{ age: 22 }
{ age: 19 }
{ age: 10, name: 'lisi' }

 */

/*******************************************/
class Node{
    constructor(element,parent){  //parent是树中比较重要的属性
        this.element = element;
        this.parent = parent;
        this.left = null;
        this.right = null;
    }
}
class BST{  //不能通过索引取数据
    constructor(compare){
        this.root = null;
        this.size= 0;  //包含着的节点个数
        this.compare = compare||this.compare;
    }
    compare(e1,e2)
    {
        return e1 - e2;
    }
    add(element){
        if(this.root == null)
        {
            this.root = new Node(element,null);
            this.size++;
            return;
        }
        else
        {
            //增加的不是根节点，第一种方式是根据递归 写循环
            let currentNode = this.root;//当前的根节点
            let compare= 0;//当前比较的结果
            let parent = null;//当前父节点

            while(currentNode){
                compare= this.compare(element,currentNode.element);
                parent = currentNode;
                if(compare > 0)  //如果大于0就找右树，小于0找左树
                {
                    currentNode= currentNode.right;
                }
                else if(compare < 0)
                {
                    currentNode = currentNode.left;
                }
                else{
                    //break;不处理
                    currentNode.element = element; //如果比较后结果一样，就有最新的去覆盖
                    return;
                }
            };

            let newNode = new Node(element,parent);
            if(compare > 0)
            {
                parent.right = newNode;
            }
            else
            {
                parent.left = newNode;
            }
        }
    }
    preorderTraversal(visitor){
        if(visitor == null)return;
        const travelsal = (node)=>{
            if(node == null)return;
            visitor.visit(node);
            travelsal(node.left);
            travelsal(node.right);
        }
        travelsal(this.root);
    }
    inorderTraversal(visitor){
        if(visitor == null)return;
        const travelsal=(node)=>{
            if(node == null)return;
            travelsal(node.left);
            visitor.visit(node);
            travelsal(node.right);
        }
        travelsal(this.root);
    }
    postorderTraversal(visitor){
        if(visitor == null)return;
        const travelsal=(node)=>{
            if(node == null)return;
            travelsal(node.left);
            travelsal(node.right);
            visitor.visit(node);
        }
        travelsal(this.root);
    }

}

let bst = new BST((e1,e2)=>{ //arr.sort默认调用sort就是简单a-b 自定义比较器
    return e1.age-e2.age;
});
let arr=[{age:10,name:'zs'},{age:8},{age:19},{age:6},{age:15},{age:22},{age:20},{age:10,name:'lisi'}];
arr.forEach((element)=>{
    bst.add(element);
});
//console.dir(bst.root,{depth:200});
//bst.preorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 10, name: 'lisi' }
{ age: 8 }
{ age: 6 }
{ age: 19 }
{ age: 15 }
{ age: 22 }
{ age: 20 }
 */
//bst.inorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 6 }
{ age: 8 }
{ age: 10, name: 'lisi' }
{ age: 15 }
{ age: 19 }
{ age: 20 }
{ age: 22 }
 */
//bst.postorderTraversal();
/*
D:\important_file\笔记>node test.js
{ age: 6 }
{ age: 8 }
{ age: 15 }
{ age: 20 }
{ age: 22 }
{ age: 19 }
{ age: 10, name: 'lisi' }

 */
bst.inorderTraversal({
    visit(node){  //ast语法树  babel-transform
        console.log(node.element,'*****');
    }
})
/*
D:\important_file\笔记>node test.js
{ age: 6 } *****
{ age: 8 } *****
{ age: 10, name: 'lisi' } *****
{ age: 15 } *****
{ age: 19 } *****
{ age: 20 } *****
{ age: 22 } *****

 */

遍历方式4种，遍历树的目的一般都是修改树，更改树的节点   访问者模式
层序遍历