二叉搜索树

二叉搜索树搜索的最坏时间复杂度为O(n)，最好时间复杂度为O(lon n)
查询；
插入；
删除；
中序遍历；

package com.liuheizi.demo;
class BinarySearchTree{
    Node root;
    class Node{
        int value;
        Node left;
        Node right;

        public Node(int i) {
            this.value = i;
        }

    }

    public Node searchElement(int key) {//查找
        if (this.root == null) {
            return null;
        }
        Node cur=this.root;
        while (cur != null) {
            if (cur.value == key) {
                return cur;
            }
            if (key > cur.value) {
                cur = cur.right;
            }
            if (key < cur.value) {
                cur = cur.left;
            }
        }
        return null;
    }

    public void insertElement(int key) {//插入元素
        if (this.root == null) {
            this.root = new Node(key);
            return;
        }
        Node parent = null;
        Node cur = this.root;
        while (cur != null) {
            if (cur.value == key) {
                return;
            }
            if (key > cur.value) {
                parent = cur;
                cur = cur.right;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
        if (key > parent.value) {
            parent.right = new Node(key);
            return;
        }
        if (key < parent.value) {
            parent.left = new Node(key);
            return;
        }
    }

    public void removeElement(int key) {//删除元素
        if (this.root == null) {
            return;
        }
        Node parent = null;
        Node cur = this.root;
        while (cur != null) {
            if (cur.value == key) {
                break;
            }
            if (key > cur.value) {
                parent = cur;
                cur = cur.right;
            }else{
                parent = cur;
                cur = cur.left;
            }
        }
        if (cur == null) {
            return;
        }
        removeInner(cur, parent);
    }
   public void removeInner(Node cur,Node parent) {
       if (cur.left == null) {
           if (cur == this.root) {
               this.root = this.root.right;
               return;
           }
           if (cur == parent.left) {
               parent.left = cur.right;
               return;
           } else {
               parent.right = cur.right;
               return;
           }
       }
       if (cur.right == null) {
           if (cur == this.root) {
               this.root = this.root.left;
               return;
           }
           if (cur == parent.left) {
               parent.left = cur.left;
               return;
           } else {
               parent.right = cur.left;
               return;
           }
       } else {
          Node targetParent=cur;
           Node target = cur.right;




           while (target.left != null) {
               targetParent = target;
               target = target.left;
           }
           cur.value=target.value;
           if (target == targetParent.left) {
               targetParent.left = target.left;
           } else {
               targetParent.right = target.right;
           }
       }
   }

    public void inOrder(Node root) {//中序遍历
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.value+" ");
        inOrder(root.right);
    }
}

public class TestDemo5 {
    public static void main(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();
        binarySearchTree.insertElement(1);
        binarySearchTree.insertElement(7);
        binarySearchTree.insertElement(14);
        binarySearchTree.insertElement(3);
        binarySearchTree.insertElement(6);
        binarySearchTree.insertElement(2);
        binarySearchTree.insertElement(8);
        binarySearchTree.insertElement(0);
        binarySearchTree.removeElement(0);
        binarySearchTree.removeElement(8);
        binarySearchTree.inOrder(binarySearchTree.root);
    }
}