node54

//二叉搜索树的实现

class Node{
	constructor(element,parent){  //parent是树中比较重要的属性
		this.element = element;
		this.parent = parent;
		this.left = null;
		this.right = null;
	}
}
class BST{  //不能通过索引取数据
	constructor(){
		this.root = null;
		this.size= 0;  //包含着的节点个数
	}
	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= element - currentNode.element;
				parent = currentNode;
				if(compare > 0)  //如果大于0就找右树，小于0找左树
				{
					currentNode= currentNode.right;
				}
				else if(compare < 0)
				{
					currentNode = currentNode.left;
				}
				else{
					//break;不处理
					curentNode.element = element; //如果比较后结果一样，就有最新的去覆盖
					return;
				}
			}

			let newNode = new Node(element,parent);
			if(compare > 0)
			{
				parent.right = newNode;
			}
			else
			{
				parent.left = newNode;
			}
		}
	}
}

let bst = new BST();
let arr=[10,8,19,6,15,22,20];
arr.forEach(element=>{
	bst.add(element);
});
console.dir(bst.root,{depth:200});
结果：
D:\important_file\笔记>node test1.js
<ref *1> Node {
  element: 10,
  parent: null,
  left: <ref *2> Node {
    element: 8,
    parent: [Circular *1],
    left: Node { element: 6, parent: [Circular *2], left: null, right: null },
    right: null
  },
  right: <ref *3> Node {
    element: 19,
    parent: [Circular *1],
    left: Node {
      element: 15,
      parent: [Circular *3],
      left: null,
      right: null
    },
    right: <ref *4> Node {
      element: 22,
      parent: [Circular *3],
      left: Node {
        element: 20,
        parent: [Circular *4],
        left: null,
        right: null
      },
      right: null
    }
  }
}

-----------------------------
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;
			}
		}
	}
}

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});
结果：
D:\important_file\笔记>node test.js
<ref *1> Node {
  element: { age: 10, name: 'lisi' },
  parent: null,
  left: <ref *2> Node {
    element: { age: 8 },
    parent: [Circular *1],
    left: Node {
      element: { age: 6 },
      parent: [Circular *2],
      left: null,
      right: null
    },
    right: null
  },
  right: <ref *3> Node {
    element: { age: 19 },
    parent: [Circular *1],
    left: Node {
      element: { age: 15 },
      parent: [Circular *3],
      left: null,
      right: null
    },
    right: <ref *4> Node {
      element: { age: 22 },
      parent: [Circular *3],
      left: Node {
        element: { age: 20 },
        parent: [Circular *4],
        left: null,
        right: null
      },
      right: null
    }
  }
}