学习打卡 JavaScript二叉树及常用方法实现

1. 二叉树的创建及基本方法代码实现

（全部封装在Tree的构造函数内）

function Tree(){		
	var num = 0;  //二叉树的结点个数
	var lNum = 0; //二叉树的叶子结点个数
	var h = 1;    //二叉树层数
	
	//结点初始化 传入 结点的值 左-子结点 以及 右-子结点
	var Node = function(key){
		this.key = key;
		this.left = null;
		this.right = null;	
	};
	
	var root = null; //定义根结点
	
	//将带着某个值的元素进行插入操作
	this.insert = function(key){
		var newNode = new Node(key);
		//如果根节点为空,则第一个插进来的元素作为根结点
		if(root === null){
			root = newNode;
		}
		else{
			insertNode(root, newNode);	
		}
		num++;
	};		
	
	//将新结点插入的具体操作
	//这里进行规定 新插入结点值小于根结点值时,插入到左子树内 反之插入到右子树内 以此类推
	var insertNode = function(node, newNode){
		if(newNode.key <= node.key){
			if(node.left === null){
				node.left = newNode;
			}
			//当左子树已经有元素存在时,将该元素作为父结点,进行递归操作
			else{
				insertNode(node.left, newNode);
			}
		}
		else{
			if(node.right === null){
				node.right = newNode;
			}
			else{
				insertNode(node.right, newNode);
			}
		}
	};
	
	//三种遍历方式都会返回一个回调函数callback, 回调函数的功能可以在测试那块进行定义
	//为统一，此处遍历方式均遵循"先左后右",具体操作视情况而定
	//先序遍历二叉树
	this.preOrderTree = function(callback){
		preOrderTreeNode(root,callback);
	};
	
	var preOrderTreeNode = function(node,callback){
		//先序遍历顺序: 根 -> 左 -> 右
		if(node != null){
			callback(node.key);
			preOrderTreeNode(node.left,callback);
			preOrderTreeNode(node.right,callback);
		}
		
	}
	
	//中序遍历二叉树
	this.inOrderTree = function(callback){
		inOrderTreeNode(root, callback);
	};	
	
	var inOrderTreeNode = function(node, callback){
		//中序遍历顺序: 左 -> 根 -> 右
		if(node != null){
			inOrderTreeNode(node.left, callback);
			callback(node.key);
			inOrderTreeNode(node.right, callback);
		}
	}
	
	//后序遍历二叉树
	this.nextOrderTree = function(callback){
		nextOrderTreeNode(root, callback);
	};
	
	var nextOrderTreeNode = function(node, callback){
		//后序遍历顺序: 左 -> 右 -> 根
		if(node != null){
			nextOrderTreeNode(node.left, callback);
			nextOrderTreeNode(node.right, callback);
			callback(node.key);
		}	
	}
	
			
	//计算叶子节点数
	this.calLeaves = function(){
		calLeavesNode(root)
		console.log("叶子节点个数为：" + lNum);
	}
	
	var calLeavesNode = function(node){
		if(node == null){
			return 0;
		}
		if(node.left == null && node.right == null){
			console.log(node.key + '');
			lNum++;
		}
		calLeavesNode(node.left); 
		calLeavesNode(node.right);
	}
	
	
	
	//求二叉树中指定结点的层次
	this.level = function(e){
		console.log('所选节点在：' + levelNode(root, e) + '层');
	}
	
	var levelNode = function(node, e){
		if(node === null){
			return 0;
		}
		else{
			if(node.key === e){
				return h;
			}
			else if(node.key < e){
				h++;
				return levelNode(node.right, e);
			}
			else{
				h++;
				return levelNode(node.left, e)
			}
		}
	}
	
	//输出二叉树的节点个数
	this.calNum = function(){
		console.log("树的节点个数为：" + num);
	}			
}

2. 测试代码：

var data = [8, 3, 10, 1, 6, 14, 4, 7, 13];
var tree = new Tree();

data.forEach(
	function(n){
		tree.insert(n);
	}
);

按照算法的逻辑，这个二叉树是长成这样的：

进行测试：

（1）结点个数：

//树的节点个数：
tree.calNum(); //树的节点个数为：9

（2）叶子结点个数：

//叶子节点
tree.calLeaves(); // 叶子节点个数为：4

（3）判断某个结点所在层数：

tree.level(13); //所选节点在：4层

（4）遍历二叉树操作（这里采用先序）

var k = 0; //orderData的索引
var orderData = []; //存储遍历二叉树以后返回的值

//此处回调函数的功能是把每个结点的值翻倍
var callback=function(content){
	orderData[k] = content * 2;
	k++;
}

tree.preOrderTree(callback);
console.log(orderData); //(9) [16, 6, 2, 12, 8, 14, 20, 28, 26]