数据结构-二叉搜索树Java实现

1，Node.java

生成基础二叉树的结构

 package com.cnblogs.mufasa.searchTree;

 /**
  * 节点配置父+左+右
  */
 public class Node{
     Node parent;
     Node leftChild;
     Node rightChild;
     int val;
     public Node(Node parent, Node leftChild, Node rightChild,int val) {
         super();
         this.parent = parent;
         this.leftChild = leftChild;
         this.rightChild = rightChild;
         this.val = val;
     }

     public Node(int val){
         this(null,null,null,val);
     }

     public Node(Node node,int val){
         this(node,null,null,val);
     }
 }

图1 Node.java结构

2，SearchBinaryTree.java

在原有二叉树的结构上，进行搜索二叉树的功能扩充：

①数据增加：递归版本插入、迭代版本

②数据删除：

③数据查找：

④数据遍历：前中后

 package com.cnblogs.mufasa.searchTree;

 public class SearchBinaryTree {

     private Node root;
     private int size;
     public SearchBinaryTree() {
         super();
     }

     /**
      * 增加节点
      * @param val
      * @return
      */
     public boolean add(int val) {
         if(root == null){//初始节点为空
             root = new Node(val);
             size++;
             return true;
         }
         //初始节点不为空
         Node node = getAdapterNode(root, val);
         Node newNode = new Node(val);
         if(node.val > val){
             node.leftChild = newNode;
             newNode.parent = node;
         }else if(node.val < val){
             node.rightChild = newNode;
             newNode.parent = node;
         }else{
             return false;//增加数据和搜索二叉树中原有数据相同不符合基本限定条件
         }
         size++;
         return true;
     }

     /**
      * 获取最合适的插入节点
      * @param node
      * @param val
      * @return
      */
     private Node getAdapterNode(Node node,int val){
         //该节点为空
         if(node == null){
             return node;
         }

         // 往左子树中插入，但没左子树，则返回
         if(node.val > val && node.leftChild == null){
             return node;
         }

         // 往右子树中插入，但没右子树，也返回
         if(node.val < val && node.rightChild == null){
             return node;
         }

         // 该节点是叶子节点，则返回
         if(node.leftChild == null && node.rightChild == null){
             return node;
         }

         //节点可以继续向下，直接递归调用
         if(node.val > val && node.leftChild != null){
             return getAdapterNode(node.leftChild, val);
         }else if(node.val < val && node.rightChild != null){
             return getAdapterNode(node.rightChild, val);
         }else{
             return node;
         }
     }

     /**
      * 进行迭代增加元素
      * @param val
      * @return
      */
     public boolean put(int val){
         return putVal(root,val);
     }

     /**
      *直接循环搜索目标节点进行数据增加
      * @param node
      * @param val
      * @return
      */
     private boolean putVal(Node node,int val){
         if(node == null){// 初始化根节点
             node = new Node(val);
             root = node;
             size++;
             return true;
         }
         //节点非空
         Node temp = node;
         Node p;
         int t;
         /**
          * 通过do while循环迭代获取最佳节点，
          */
         do{
             p = temp;
             t = temp.val-val;
             if(t > 0){
                 temp = temp.leftChild;
             }else if(t < 0){
                 temp = temp.rightChild;
             }else{
                 temp.val = val;//增加数据和搜索二叉树中原有数据相同不符合基本限定条件
                 return false;
             }
         }while(temp != null);

         Node newNode = new Node(p, val);
         if(t > 0){
             p.leftChild = newNode;
         }else if(t < 0){
             p.rightChild = newNode;
         }
         size++;
         return true;
     }

     /**
      * 节点删除
      * @param val
      * @return
      */
     public boolean delete(int val){
         Node node = getNode(val);
         if(node == null){//没有该节点
             return false;
         }
         Node parent = node.parent;
         Node leftChild = node.leftChild;
         Node rightChild = node.rightChild;

         //以下所有子节点为空的情况，则表明删除的节点是【叶节点】
         if(leftChild == null && rightChild == null){//没有子节点
             if(parent != null){
                 if(parent.leftChild == node){
                     parent.leftChild = null;
                 }else if(parent.rightChild == node){
                     parent.rightChild = null;
                 }
             }else{//不存在父节点，则表明删除节点为【根节点】，直接返回空
                 root = null;
             }
             node = null;
             return true;

         }else if(leftChild == null && rightChild != null){// 只有右节点
             if(parent != null && parent.val > val){// 存在父节点，且node位置为父节点的左边
                 parent.leftChild = rightChild;
             }else if(parent != null && parent.val < val){// 存在父节点，且node位置为父节点的右边
                 parent.rightChild = rightChild;
             }else{//父节点不存在！！！
                 root = rightChild;
             }
             node = null;
             return true;

         }else if(leftChild != null && rightChild == null){// 只有左节点
             if(parent != null && parent.val > val){// 存在父节点，且node位置为父节点的左边
                 parent.leftChild = leftChild;
             }else if(parent != null && parent.val < val){// 存在父节点，且node位置为父节点的右边
                 parent.rightChild = leftChild;
             }else{//父节点不存在！！！
                 root = leftChild;
             }
             node = null;
             return true;

         }else if(leftChild != null && rightChild != null){// 两个子节点都存在，相当于直接替换节点
             Node successor = getSuccessor(node);// 这种情况，一定存在后继节点
             int temp = successor.val;
             boolean delete = delete(temp);
             if(delete){
                 node.val = temp;
             }
             successor = null;
             return true;
         }
         return false;
     }

     /**
      *
      * @param node
      * @return
      */
     private Node getSuccessor(Node node){
         if(node.rightChild != null){//肯定不为空
             Node rightChild = node.rightChild;
             while(rightChild.leftChild != null){//不断的向左转向搜索数值
                 rightChild = rightChild.leftChild;
             }
             return rightChild;
         }
         //右节点为空这个不存在啊！！！
         Node parent = node.parent;
         while(parent != null && (node == parent.rightChild)){
             node = parent;
             parent = parent.parent;
         }
         return parent;
     }

     /**
      * 搜索节点
      * @param val
      * @return
      */
     public Node getNode(int val){
         Node temp = root;
         int t;
         do{//直接使用循环遍历的方法
             t = temp.val-val;
             if(t > 0){
                 temp = temp.leftChild;
             }else if(t < 0){
                 temp = temp.rightChild;
             }else{
                 return temp;
             }
         }while(temp != null);
         return null;
     }

     /**
      * 节点删除
      * @param val
      * @return
      */
     public boolean remove(int val){
         Node node = getNode(val);
         if(node == null){
             return false;
         }

         if(node.leftChild == null){// 1、左节点不存在，右节点可能存在，包含两种情况  ，两个节点都不存在和只存在右节点
             transplant(node, node.rightChild);
         }else if(node.rightChild == null){//2、左孩子存在，右节点不存在
             transplant(node, node.leftChild);
         }else{// 3、两个节点都存在
             Node successor = getSuccessor(node);// 得到node后继节点
             if(successor.parent != node){// 后继节点存在node的右子树中。
                 transplant(successor, successor.rightChild);// 用后继节点的右子节点替换该后继节点
                 successor.rightChild = node.rightChild;// 将node节点的右子树赋给后继节点的右节点，即类似后继与node节点调换位置
                 successor.rightChild.parent = successor;// 接着上一步  给接过来的右节点的父引用复制
             }
             transplant(node, successor);
             successor.leftChild = node.leftChild;
             successor.leftChild.parent = successor;
         }
         return true;
     }
     /**
      * 将child节点替换node节点
      * @param node    要删除的节点
      * @param child   node节点的子节点
      */
     private void transplant(Node node,Node child){
         /**
          * 1、先判断 node是否存在父节点
          *    1、不存在，则child替换为根节点
          *    2、存在，则继续下一步
          * 2、判断node节点是父节点的那个孩子(即判断出 node是右节点还是左节点)，
          *    得出结果后，将child节点替换node节点 ，即若node节点是左节点 则child替换后 也为左节点，否则为右节点
          * 3、将node节点的父节点置为child节点的父节点
          */

         if(node.parent == null){
             this.root = child;
         }else if(node.parent.leftChild == node){
             node.parent.leftChild = child;
         }else if(node.parent.rightChild == node){
             node.parent.rightChild = child;
         }
         if(child != null){
             child.parent = node.parent;
         }
     }

     public void print(int type){//方法的重载
         if(type==0){//前序
             printPre(root);
         }else if(type==1){
             printMid(root);
         }else if(type==2){
             printEnd(root);
         }
     }

     private void printPre(Node root){//前序遍历
         if(root != null){
             System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
             printPre(root.leftChild);
             printPre(root.rightChild);
         }
     }

     private void printMid(Node root){//中序遍历
         if(root != null){
             printMid(root.leftChild);
             System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
             printMid(root.rightChild);
         }
     }

     private void printEnd(Node root){//后序遍历
         if(root != null){
             printEnd(root.leftChild);
             printEnd(root.rightChild);
             System.out.println(root.val);// 位置在中间，则中序，若在前面，则为先序，否则为后续
         }
     }

 }

图2 SearchBinaryTree.java结构

3，JavaDemo.java

 package com.cnblogs.mufasa.searchTree;

 public class JavaDemo {
     public static void main(String[] args) {
         SearchBinaryTree tree=new SearchBinaryTree();
         tree.add(5);
         tree.add(1);
         tree.add(100);
         tree.add(50);
         tree.add(22);
         tree.add(48);
         tree.print(2);
     }
 }

4，特别鸣谢

https://www.cnblogs.com/qm-article/p/9279655.html