[数据结构]P2.1 二叉搜索树

二叉树就是每个节点最多有两个分叉的树。这里我们写一写一个典型的例子二叉搜索树，它存在的实际意义是什么呢?

在P1.1链表中，我们清楚了链表的优势是善于删除添加节点，但是其取值很慢；数组的优势是善于取值，但是不利于删除添加节点。

而二叉搜索树，正是两者的折中方案。首先，它是树状结构，因此它便于插入和删除节点，需要花费LogN级别的时间，其次，它

在每一个节点上都满足`左子树 <= 当前节点 <= 右子树`,因此便于使用二叉搜索，所以查找数据和取数据也是LogN级别的。

 

时间比较	链表	二叉搜索树	数组
取值	N	LogN	C
查找	N	LogN	有序数组:LogN 无序数组:N
插入和删除	C	LogN	N

 

 

 

 

 

 

常见的二叉搜索树操作有:

1.插入新节点

2.按值查找节点

3.删除节点

4.三种遍历方式

5.二叉搜索树的宽度

6.二叉搜索树最大距离

 

TODO : 待解析

 

Java代码:

 

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;
        }

        @Override
        public 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. 计算当前层size
                int 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. 计算当前层depth
                depth ++;
                // 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());

    }
}

 result:

层次遍历
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