生成一棵二叉樹
二叉樹實現原理
把第一位當做根節點，比根節點小的數放在左子樹上，比根節點大的數放到右子樹上，以此類推。
把下面陣列生成一個二叉樹：
let nodes = [8,3,6,4,9,11,2,5,7];結構如下
生成的二叉樹物件如下
let tree = { key: 8, left: { key: 3, left: { key: 2, left: null, right: null }, right: { key: 6, left: { key: 4, left: null, right: { key: 5, left: null, right: null } }, right: { key: 7, left: null, right: null } } } right: { key: 9, left: null, right: { key: 11, left: null, right: null } } }複製程式碼
生成二叉樹實現程式碼
//API:
//insert新增一個子樹，傳值Number
//bulkInsert批量新增子樹，傳值Array
//showTree返回二叉樹物件
class BinaryTree {
constructor(tree = []) {
this.root = null;//樹根
this.Node = key => {
//生成一個新的子樹
let _obj = Object.create(null, {});
_obj.key = key;
_obj.left = null;
_obj.right = null;
return _obj;
}
//初始化二叉樹
if (typeof tree === 'number') {
this.insert(tree);
} else if (Array.isArray(tree)) {
this.bulkInsert(tree)
} else {
console.error('請輸入Number型別或者Array型別的引數')
}
}
insert(key) {
//新增一個新子樹
let newNode = this.Node(key);
let _insertNode = (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)
}
}
}
if (this.root === null) {
//如果沒有根節點，那麼把傳入的值當根節點
this.root = newNode;
} else {
//如果有根節點，那麼把傳入的值插到二叉樹上
_insertNode(this.root, newNode);
}
}
bulkInsert (nodes) {
nodes.forEach(key => {
//遍歷陣列，插入子樹
this.insert(key);
})
}
showTree () {
//返回二叉樹物件
return this.root;
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);
let tree = binaryTree.showTree();複製程式碼先序遍歷、中序遍歷、後序遍歷
- 先序遍歷
- 根左右
- 中序遍歷
- 左根右
- 後序遍歷
- 左右根
class BinaryTree {
......//生成樹的程式碼
inOrderTraverse (fn) {
//中序遍歷，傳入一個回撥函式
let inOrderTraverseNode = (node, callback) => {
if (node !== null) {
inOrderTraverseNode(node.left, callback);
callback(node.key);
inOrderTraverseNode(node.right, callback);
}
}
inOrderTraverseNode(this.root, fn)
}
preOrderTraverse (fn) {
//先序遍歷，傳入一個回撥函式
let preOrderTraverseNode = (node, callback) => {
if (node !== null) {
callback(node.key);
preOrderTraverseNode(node.left, callback);
preOrderTraverseNode(node.right, callback);
}
}
preOrderTraverseNode(this.root, fn)
}
postOrderTraverse (fn) {
//先序遍歷，傳入一個回撥函式
let postOrderTraverseNode = (node, callback) => {
if (node !== null) {
postOrderTraverseNode(node.left, callback);
postOrderTraverseNode(node.right, callback);
callback(node.key);
}
}
postOrderTraverseNode(this.root, fn)
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);
let arr1 = [],
arr2 = [],
arr3 = [];
binaryTree.inOrderTraverse(key => {
arr1.push(key);//中序遍歷[2, 3, 4, 5, 6, 7, 8, 9, 11]
})
binaryTree.preOrderTraverse(key => {
arr2.push(key);//先序遍歷[8, 3, 2, 6, 4, 5, 7, 9, 11]
})
binaryTree.postOrderTraverse(key => {
arr3.push(key);//後序遍歷[2, 5, 4, 7, 6, 3, 11, 9, 8]
})複製程式碼二叉樹節點查詢
- 查詢最大值、最小值
class BinaryTree {
......//生成樹的程式碼與三種遍歷程式碼
min() {
let node = this.root;
if (node) {
//迴圈遍歷左子樹
while (node && node.left !== null) {
node = node.left;
}
return node.key;
}
}
max() {
let node = this.root;
if (node) {
//迴圈遍歷右子樹
while (node && node.right !== null) {
node = node.right;
}
return node.key;
}
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);
let min = binaryTree.min();//2
let max = binaryTree.max();//11複製程式碼- 查詢二叉樹中節點是否存在
class BinaryTree {
......//生成樹的程式碼與三種遍歷程式碼
search(key) {
let searchNode = (node, key) => {
if (node === null) {
return false;
}
if (key < node.key) {
//當查詢的值小於當前節點的值，則遞迴其左子樹
return searchNode(node.left, key);
} else if (key > node.key){
//當查詢的值大於當前節點的值，則遞迴其右子樹
return searchNode(node.right, key);
} else {
return true;
}
}
return searchNode(this.root, key)
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);
let inTree1 = binaryTree.showTree(2);//true
let inTree2 = binaryTree.showTree(1);//false複製程式碼二叉樹節點刪除
- 需要判斷這個節點是否還有子樹，有三種情況，無子樹，有單子樹，有雙子樹。
class BinaryTree {
......//生成樹的程式碼與三種遍歷程式碼
remove(key) {
let findMinNode = (node, key) => {
//查詢最小子節點
let node = node || this.root;
if (node) {
while (node && node.left !== null) {
node = node.left;
}
return node;
}
return null;
}
let removeNode = (node, key) => {
if (node === null) {
//如果為null，返回null
return null
}
if (key < node.key) {
//如果值小於當前節點值，遞迴其左子樹
node.left = removeNode(node.left, key);
return node;
} else if (key > node.key) {
//如果值大於當前節點值，遞迴其右子樹
node.right = removeNode(node.right, key);
return node;
} else {
//如果值等於當前節點值，做該節點刪除操作
if (node.left === null && node.right === null) {
//如果該節點沒有左右子樹，直接使其為null
node = null;
return node;
}
if (node.left === null) {
//如果該節點只有右子樹，則將該節點指向它的右子樹
node = node.right;
return node;
} else if (node.right === null) {
//如果該節點只有左子樹，則將該節點指向它的左子樹
node = node.left;
return node;
}
if (node.left !== null && node.right !== null) {
//如果該節點有左右子樹，則把找到它的右子樹的最小子節點，並使該節點的值等於它的右子樹的最小子節點的值，然後刪除它的右子樹的最小子節點
let aux = findMinNode(node.right);
node.key = aux;
node.right = removeNode(node.right, aux.key);
return node;
}
}
}
this.root = removeNode(this.root, key)
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);複製程式碼JS二叉樹完整程式碼
class BinaryTree {
constructor(tree = []) {
this.root = null;//樹根
this.Node = key => {
//生成一個新的子樹
let _obj = Object.create(null, {});
_obj.key = key;
_obj.left = null;
_obj.right = null;
return _obj;
}
//初始化二叉樹
if (typeof tree === 'number') {
this.insert(tree);
} else if (Array.isArray(tree)) {
this.bulkInsert(tree)
} else {
console.error('請輸入Number型別或者Array型別的引數')
}
}
insert(key) {
//新增一個新子樹
let newNode = this.Node(key);
let _insertNode = (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)
}
}
}
if (this.root === null) {
//如果沒有根節點，那麼把傳入的值當根節點
this.root = newNode;
} else {
//如果有根節點，那麼把傳入的值插到二叉樹上
_insertNode(this.root, newNode);
}
}
bulkInsert (nodes) {
nodes.forEach(key => {
//遍歷陣列，插入子樹
this.insert(key);
})
}
showTree () {
//返回二叉樹物件
return this.root;
}
inOrderTraverse (fn) {
let inOrderTraverseNode = (node, callback) => {
if (node !== null) {
inOrderTraverseNode(node.left, callback);
callback(node.key);
inOrderTraverseNode(node.right, callback);
}
}
inOrderTraverseNode(this.root, fn)
}
preOrderTraverse (fn) {
let preOrderTraverseNode = (node, callback) => {
if (node !== null) {
callback(node.key);
preOrderTraverseNode(node.left, callback);
preOrderTraverseNode(node.right, callback);
}
}
preOrderTraverseNode(this.root, fn)
}
postOrderTraverse (fn) {
let postOrderTraverseNode = (node, callback) => {
if (node !== null) {
postOrderTraverseNode(node.left, callback);
postOrderTraverseNode(node.right, callback);
callback(node.key);
}
}
postOrderTraverseNode(this.root, fn)
}
min() {
let node = this.root;
if (node) {
while (node && node.left !== null) {
node = node.left;
}
return node.key;
}
}
max() {
let node = this.root;
if (node) {
while (node && node.right !== null) {
node = node.right;
}
return node.key;
}
}
search(key) {
let searchNode = (node, key) => {
if (node === null) {
return false;
}
if (key < node.key) {
return searchNode(node.left, key);
} else if (key > node.key){
return searchNode(node.right, key);
} else {
return true;
}
}
return searchNode(this.root, key)
}
remove(key) {
let findMinNode = (node, key) => {
let node = node || this.root;
if (node) {
while (node && node.left !== null) {
node = node.left;
}
return node;
}
return null;
}
let removeNode = (node, key) => {
if (node === null) {
return null
}
if (key < node.key) {
node.left = removeNode(node.left, key);
return node;
} else if (key > node.key) {
node.right = removeNode(node.right, key);
return node;
} else {
if (node.left === null && node.right === null) {
node = null;
return node;
}
if (node.left === null) {
node = node.right;
return node;
} else if (node.right === null) {
node = node.left;
return node;
}
if (node.left !== null && node.right !== null) {
let aux = findMinNode(node.right);
node.key = aux;
node.right = removeNode(node.right, aux.key);
return node;
}
}
}
this.root = removeNode(this.root, key)
}
}
let nodes = [8,3,6,4,9,11,2,5,7];
let binaryTree = new BinaryTree(nodes);複製程式碼