/**
* parent: 双亲节点
* left: 左子节点
* right: 右子节点
*/
interface TreeNode {
left: TreeNode | null,
right: TreeNode | null,
data: any,
count: number
}
class TreeNode {
constructor(data: any, left: TreeNode | null, right: TreeNode | null) {
this.data = data;
this.left = left;
this.right = right;
this.count = 1;
}
}
//二叉排序树
interface BsTree {
root: TreeNode | null
//删除一个节点
_removeNode(node: TreeNode, data: any): void
//删除给定的数据节点
remove(data: any): void
//向二叉树中插入节点
insert(data: any): void
//寻找给定数据的节点
find(data: any): TreeNode | null
//获得最小值的节点
getMinNode(node: TreeNode): TreeNode | null
//获得最大值的节点
getMaxNode(node: TreeNode): TreeNode | null
display(): void
}
class BsTree {
root: TreeNode | null = null
/**
*
* @param node 要删除的节点
* @param data 要删除值
* 递归删除节点
* 待删除的节点是叶子节点。
* 待删除的节点没有左子节点，或者没有右子节点。
* 待删除的节点的左右子节点均存在。
* 当待删除的节点时叶子节点时，这种情况比较简单，直接将待删除的节点置空返回即可。
* 当待删除的节点没有左子节点时，返回该节点的右孩子节点，并删除该节点。待删除节点没有右节点时类似处理。
* 比较麻烦的是最后一种情况，待删除的节点的左右子节点均存在时，可以有两种做法：要么查找待删除节点左子树上的最大值，要么查找其右子树上的最小值。
* 这里使用查找其右子树上的最小值的方法。在找到待删除节点的右子树上的最小值后，创建一个临时节点，将临时节点上的值复制到待删除节点，然后再删除临时节点。
*/
_removeNode(node: TreeNode, data: any): TreeNode | null {
if (node == null) {
return null;
}
if (data == node.data) {
if (node.left == null && node.right == null) {
return null;
}
//没有左节点的节点
if (node.left == null) return node.right;
//没有右节点的节点
if (node.right == null) return node.left;
//有两个节点的节点
/*
做法：
找到待删除节点的右子树上的最小值创建一个临时节点。
将临时节点上的值复制到待删除节点，然后再删除临时节点
*/
// 寻找右子树上的最小值
let tmpNode = this.getMinNode(node.right);
if (tmpNode) {
node.data = tmpNode.data;
node.right = this._removeNode(node.right, tmpNode.data);
return node;
}
} else if (data < node.data && node.left) { // 待删除节点在左子树上
node.left = this._removeNode(node.left, data);
return node;
} else { // 待删除节点在右子树上
if (node.right) {
node.right = this._removeNode(node.right, data);
return node;
}
}
return null
}
/**
*
* @param data 要删除的节点值
*/
//删除给定的数据节点
remove(data: any): void {
if (this.root) {
console.log(this._removeNode(this.root, data));
}
}
/**
* 如果在插入时，root节点为空，则直接将新节点赋给root节点即可。
* 如果新的节点值小于当前节点值，说明待插入的位置应在在当前节点的左子树上，那么在大于时，就应该在当前节点的右子树上。进而更新当前节点所指向的节点，直到当前节点为空时，说明找到了正确的插入位置。
*/
insert(data: any): void {
let newNode = new TreeNode(data, null, null);
let parentNode = null;
if (this.root === null) {
this.root = newNode;
} else {
let currNode: any = this.root;
while (true) {
parentNode = currNode;
if(newNode.data > currNode.data) {
currNode = currNode.right;
if(!currNode) {
parentNode.right = newNode;
break;
}
} else if(newNode.data < currNode.data) {
currNode = currNode.left;
if(!currNode) {
parentNode.left = newNode;
break;
}
} else if(currNode.data === newNode.data) {
currNode.count++;
break;
}
}
}
}
//寻找给定数据的节点
find(data: any): TreeNode | null {
if (!this.root) {
return null;
}
let currNode: TreeNode = this.root;
while (currNode) {
if (data > currNode.data && currNode.right) {
currNode = currNode.right;
} else if (data < currNode.data && currNode.left) {
currNode = currNode.left;
} else {
return currNode;
}
}
return null;
}
//获得最小值的节点
getMinNode(node: TreeNode | null = this.root): TreeNode | null {
let currNode = node;
while (currNode?.left) {
currNode = currNode.left;
}
return currNode;
}
//获得最大值的节点
getMaxNode(node: TreeNode | null = this.root): TreeNode | null {
let currNode = node;
while (currNode?.right) {
currNode = currNode.right;
}
return currNode;
}
preOrderRec(node: any = this.root) {
let result = '';
if (!(node == null)) {
result += `${node.data} `;
result += this.preOrderRec(node.left);
result += this.preOrderRec(node.right);
}
return result;
}
// 前序遍历非递归方法
preOrderNonRec(node:any = this.root) {
let stack:Array<any> = [];
let result = '';
while(node || stack.length) {
if(node) {
result += `${node.data} `;
stack.push(node);
node = node.left;
} else {
node = stack.pop();
node = node.right;
}
}
return result;
}
inOrderRec(node:any = this.root) {
let result = '';
if(!(node == null)) {
result += this.inOrderRec(node.left);
result += `${node.data} `;
result += this.inOrderRec(node.right);
}
return result;
}
//中序遍历非递归算法
inOrderNonRec(node:any = this.root) {
let result = '';
let stack:Array<any> = [];
while(node || stack.length) {
if(node) {
stack.push(node);
node = node.left
} else {
node = stack.pop();
result+=`${node.data} `;
node = node.right;
}
}
return result;
}
//后续遍历
postOrderRec(node:any = this.root) {
let result = '';
if(!(node == null)) {
result += this.postOrderRec(node.left);
result += this.postOrderRec(node.right);
result += `${node.data} `
}
return result;
}
}
let myTree = new BsTree();
myTree.insert(20);
myTree.insert(13);
myTree.insert(7);
myTree.insert(9);
myTree.insert(15);
myTree.insert(14);
myTree.insert(42);
myTree.insert(22);
myTree.insert(21);
myTree.insert(24);
myTree.insert(57);
myTree.remove(9);
console.log(myTree.postOrderRec())
