package ds4.binaryTree;import java.util.ArrayDeque;
import java.util.Queue;/*** 二叉搜索树*/
public class BinarySearchTree {static class Node {long data;Node left;Node right;public Node(long data) {this.data = data;}@Overridepublic String toString() {return "N["+data+"]";}}static class Tree{Node root;Tree(){}/*** 添加节点: 时间消耗LogN* @param node*/public void addNode(Node node){if(node == null){return;}if(this.root == null){this.root = node;return;}Node current = root;Node parent = current;while(current != null){parent = current;if(current.data >= node.data){current = current.left;}else{current = current.right;}}if(parent.data >= node.data){parent.left = node;}else{parent.right = node;}}/*** 查找节点* 时间消耗LogN* @param data* @return*/public Node fineNodeByVal(long data){Node result = null;if(this.root == null){return result;}Node current = this.root;while(current != null){if(current.data > data){current = current.left;}else if(current.data < data){current = current.right;}else{result = current;break;}}return result;}/*** 删除某个节点* @param node*/public void removeNode(Node node){if(this.root == null){return;}if(node == null){return;}if(this.root == node){this.root = null;node.left = node.right = null;return;}// 寻找其父节点Node current = root;Node parent = current;while(current != null){if(current == node){break;}parent = current;if(current.data < node.data){current = current.right;}else{current = current.left;}}if(current == null){System.out.println("没有找到这个节点!");return;}if(node.left == null && node.right == null){ //左右都为空// 找到其父节点直接删除即可if(parent.left == null){parent.left = null;}else{parent.right = null;}return;}else if(node.left != null && node.right == null){ // 左子树不为空，而右子树为空// 找到其父节点直接嫁接if(parent.left == null){parent.left = node.left;}else{parent.right = node.left;}}else if(node.right != null && node.left == null){ // 右子树不为空，左子树为空//找到父节点直接嫁接if(parent.right == node){parent.right = node.right;}else{parent.left = node.right;}}else{ // 左右子树都不为空//找到左枝最靠右节点，删除；并找到带删除父节点，将待删除节点用左枝最右节点替代Node current1 = node;Node parent1 = node;while (current1.right != null){parent1 = current1;current1 = current1.right;}if(parent1.right == current1){parent1.right = null;}else{parent1.left = null;}// 到这里current1为最右左节点，parent1为current1的父节点，已经解除了父子关系current1.left = node.left;current1.right = node.right;if(parent.right == current){parent.right = current1;}else{parent.left = current1;}node.left = null;node.right = null;}}/*** 先根遍历*/public void firstRootIndex(Node root){if(root != null){System.out.println(root.data);if(root.left != null){firstRootIndex(root.left);}if(root.right != null){firstRootIndex(root.right);}}}/*** 后根遍历* @param root*/public void lastRootIndex(Node root){if(root != null){if(root.left != null){lastRootIndex(root.left);}if(root.right != null){lastRootIndex(root.right);}System.out.println(root.data);}}/*** 中序遍历* @param root*/public void midRootIndex(Node root){if(root != null){if(root.left != null){lastRootIndex(root.left);}System.out.println(root.data);if(root.right != null){lastRootIndex(root.right);}}}/*** 层序遍历* @param root*/public void layerIndex(Node root){// 1.当前层Queue<Node> currentLayer = new ArrayDeque<Node>();// 2.临时存储下一层节点Queue<Node> sonLayer = new ArrayDeque<Node>();if(this.root == null){return;}else{currentLayer.add(this.root);}while(currentLayer.size() != 0){// 1.当前层节点出队列下一层入队列
                sonLayer.clear();while(currentLayer.size() != 0){Node node = currentLayer.poll();// 2.遍历本层节点
                    System.out.print(node);if(node.left != null){sonLayer.add(node.left);}if(node.right != null){sonLayer.add(node.right);}}System.out.println();// 3.将sonLayer赋给currentLayer,sonLayer重新创建对象currentLayer = sonLayer;sonLayer = new ArrayDeque<Node>();}}/*** 计算树的宽度* 也就是树中节点数最多的层次对应的节点数* 思路1: 进行一次树的遍历，也就是过一遍树的所有节点，将每一层的数据存储在Map数据结构中* 思路2: 设置队列进行层序遍历，将这层的节点数量计算一下，然后出队列，下一层的节点入队列** 思路2提供了除去以上三种遍历方式以外的第三种遍历方式*/public int computeWidth(){int maxSize = 0;// 1.当前层Queue<Node> currentLayer = new ArrayDeque<Node>();// 2.临时存储下一层节点Queue<Node> sonLayer = new ArrayDeque<Node>();if(this.root == null){return maxSize;}else{currentLayer.add(this.root);}while(currentLayer.size() != 0){// 1. 计算当前层sizeint currentSize = currentLayer.size();maxSize = maxSize>currentSize?maxSize:currentSize;// 2.当前层节点出队列下一层入队列
                sonLayer.clear();while(currentLayer.size() != 0){Node node = currentLayer.poll();if(node.left != null){sonLayer.add(node.left);}if(node.right != null){sonLayer.add(node.right);}}// 3.将sonLayer赋给currentLayer,sonLayer重新创建对象currentLayer = sonLayer;sonLayer = new ArrayDeque<Node>();}return maxSize;}/*** 计算二叉树中两点的最大距离* 思路1: 左枝树长 + 右枝树长 算法:节省时间，占空间* 思路2: 迭代 算法:节省空间，占用时间*/public int computeMaxDistance(){if(this.root == null){return 0;}return computeDepth(this.root.left) + computeDepth(this.root.right);}/*** 计算二叉树的深度* 和刚才计算宽度的思路一样，只是用深度来计算* @return*/public int computeDepth(Node root){int depth = 0;// 1.当前层Queue<Node> currentLayer = new ArrayDeque<Node>();// 2.临时存储下一层节点Queue<Node> sonLayer = new ArrayDeque<Node>();if(root == null){return depth;}else{currentLayer.add(root);}while(currentLayer.size() != 0){// 1. 计算当前层depthdepth ++;// 2.当前层节点出队列下一层入队列
                sonLayer.clear();while(currentLayer.size() != 0){Node node = currentLayer.poll();if(node.left != null){sonLayer.add(node.left);}if(node.right != null){sonLayer.add(node.right);}}// 3.将sonLayer赋给currentLayer,sonLayer重新创建对象currentLayer = sonLayer;sonLayer = new ArrayDeque<Node>();}return depth;}}public static void main(String[] args) {Tree tree = new Tree();tree.addNode(new Node(100));tree.addNode(new Node(200));tree.addNode(new Node(20));tree.addNode(new Node(177));Node nodeToRemove = new Node(88);tree.addNode(nodeToRemove);tree.addNode(new Node(90));tree.addNode(new Node(60));// 层序遍历System.out.println("层次遍历");tree.layerIndex(tree.root);// 先根遍历System.out.println("先根遍历");tree.firstRootIndex(tree.root);// 计算宽度与深度tree.addNode(new Node(188));System.out.println("width:"+tree.computeWidth());System.out.println("depth:"+tree.computeDepth(tree.root));// 删除节点
        tree.removeNode(nodeToRemove);// 层序遍历System.out.println("层序遍历");tree.layerIndex(tree.root);// 后根遍历System.out.println("后根遍历");tree.lastRootIndex(tree.root);System.out.println("最大距离:"+tree.computeMaxDistance());}
}

层次遍历
N[100]
N[20]N[200]
N[88]N[177]
N[60]N[90]
先根遍历
100
20
88
60
90
200
177
width:3
depth:4
层序遍历
N[100]
N[20]N[200]
N[90]N[177]
N[60]N[188]
后根遍历
60
90
20
188
177
200
100
最大距离:6