javascript-二叉树

二叉树

二叉树（Binary Tree）也称为二分树、二元树或对分树等。它是n（n≥0）个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。

重要性质

性质1：一棵非空二叉树的第i层上最多有2i-1个结点（i≥1）。
性质2：一棵深度为k的二叉树中，最多具有2k-1个结点，最少有k个结点。
性质3：对于一棵非空的二叉树，度为0的结点（即叶子结点）总是比度为2的结点多一个，即如果叶子结点数为n0，度数为2的结点数为n2，则有n0=n2+1。
证明：用n0表示度为0（叶子结点）的结点总数，用n1表示度为1的结点总数，n2表示度为2的结点总数，n表示整个完全二叉树的结点总数,则n=n0+n1+n2。根据二叉树和树的性质可知n=n1+2×n2+1（所有结点的度数之和+1=结点总数），根据两个等式可知n0+n1+n2=n1+2×n2+1，所以，n2=n0-1，即n0=n2+1。因此，答案为1。
性质4：具有n个结点的完全二叉树的深度为「log2 n」+1，其中“「」”表示向下取整。

构造一个二叉树

			class Node{
				constructor(data) {
				    this.data=data;
				    this.left=null;
				    this.right=null;
				}
				
			}
			
				
			class BTS{
				constructor() {
				    this.root=null;
				}
				//插入节点
				insert(data){
					const n=new Node(data);
					if(this.root===null) {
						this.root=n;
					}else{
						var parent;
						var current=this.root;
						while(true){
							parent=current;
							if(data<current.data){
								current=current.left;
								if(current===null){
									parent.left=n;
									break
								}
							}else{
								current=current.right;
								if(current===null){
									parent.right=n;
									break
								}
							}
						}
					}
					
				}
				//查找
				search(data){
					if(this.root==null){
						return null;
					}
					var current=this.root;
					while(current&&current.data!==data){
						if(data<current.data){
							current=current.left;
						}else{
							current=current.right;
						}
					}
					return current
				}
				
				//先序遍历 根左右
				preOrder(callback){
					this.preOrderNode(this.root,callback);
				}
				preOrderNode(node,callback){
					if(node!==null){
					callback(node.data);
					this.preOrderNode(node.left,callback)
					this.preOrderNode(node.right,callback)
					}
				}
				//中序遍历  左根右
				middleOrder(callback){
					this.middleOrderNode(this.root,callback);
				}
				middleOrderNode(node,callback){
					if(node!==null){
					this.middleOrderNode(node.left,callback)
					callback(node.data);
					this.middleOrderNode(node.right,callback)
					}
				}
				//后序遍历  左右根
				LastOrder(callback){
					this.LastOrderNode(this.root,callback);
				}
				LastOrderNode(node,callback){
					if(node!==null){
					this.LastOrderNode(node.left,callback)
					this.LastOrderNode(node.right,callback)
					callback(node.data);
					}
				}
			}
			
			function merge(b1,b2){
				if(b1==null&&b2==null){
					return null;
				}else if(b1==null){
					return b2
				}else if(b2==null){
					return b1
				}
				b1.data=b1.data+b2.data;
				b1.left=merge(b1.left,b2.left);
				b1.right=merge(b1.right,b2.right);
				return b1;
				
			}
			
			//遍历时的回调函数
			function callback(res){
				console.log(res);
			}
			var b=new BTS();
			b.insert(4);
			b.insert(3)
			b.insert(5)
			b.insert(1)
			b.insert(9)
			console.log(b)
			console.log(b.search(3))
			console.log("-----------------")
			b.preOrder(callback)
			console.log("-----------------")
			b.middleOrder(callback)
			console.log("-----------------")
			b.LastOrder(callback)
			console.log("-----------合并二叉树-------------")
			var b2=new BTS();
			b2.insert(3);
			b2.insert(1);
			b2.insert(2);
            console.log(merge(b.root,b2.root))

结果：