二叉搜索树 思想 JAVA实现

Posted dev1ce

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了二叉搜索树 思想 JAVA实现相关的知识,希望对你有一定的参考价值。

二叉搜索树:一棵二叉搜索树是以一棵二叉树来组织的,这样一棵树可以使用链表的数据结构来表示(也可以采用数组来实现)。除了key和可能带有的其他数据外,每个节点还包含Left,Right,Parent,它们分别指节点的左孩子,右孩子,和父节点。

一个二叉搜索树总是满足 :node.left.key<node.key<=node.right.key。

以下是一个用java实现的二叉搜索树,包含了查找最大值,最小值,查找某一节点,插入和删除操作。

接下来通过代码来分析二叉搜索树中的思想:在代码实现二叉搜索树中,大量采用了递归的思想,同样可以采用循环去递归来实现。

插入:自根节点起递归调用“寻找合适位置方法”,使二叉搜索树始终满足条件  node.left.key<node.key<=node.right.key

查询:自根节点起递归调用“查找孩子的方法”。查找孩子的方法采用的思想是,判断node.key==key 返回,node.key>key 递归查找左子树,node.key<=key 递归查             找右子树。

查询最小值:递归查找左孩子,直到最后一个左孩子。

查询最大值:递归查找右孩子,直到最后一个右孩子。

遍历:

前序遍历:根的关键字输出在左右子树的关键字之前。根 左 右。

中序遍历:根的关键字输出在左右子树的关键字之间。左 根 右。

后序遍历:根的关键字输出在左右子树的关键字之后。左 右 根。

删除:删除一棵搜索树是比较麻烦的。共有以下4种情况

1.删除节点没有孩子,直接断开连接即可

2.a图:删除节点没有左孩子,将右孩子移至删除节点处

3.b图:删除节点没有右孩子,将左孩子移至删除节点处

4.c图:有左右孩子,右孩子 没有 左孩子,将右孩子移动至删除节点处,将左孩子的父节点连接值右孩子。

5.d图:有左右孩子,且右孩子也有左右孩子,则查找右孩子的最小节点,将最小节点移至删除节点处。

public class SearchTree {
                     //树的根节点
      private Node Root = null;
                     //内部类,结点
      private class Node{

         Node parent;//父节点
         Node Left;//左孩子
         Node Right;//右孩子
         int keyValue;//关键字

         public Node(Node parent,
                Node Left,
                Node Right,
                int keyValue) {
          this.parent = parent;
          this.Left = Left;
          this.Right = Right;
          this.keyValue = keyValue;
         }
      }

      public void delete(int value) {
        Node deleteNode = this.search(value);//查找删除节点
        if(deleteNode.Left==null) {//没有左孩子
          transplant(deleteNode, deleteNode.Right);
        }else if(deleteNode.Right==null) {//没有右孩子
          transplant(deleteNode, deleteNode.Left);
        }else {//有左右孩子时
          Node min = this.min(deleteNode.Right);//查找右孩子的最小节点
          if(min.parent!=deleteNode) {
            transplant(min, min.Right);
            min.Right = deleteNode.Right;
            min.Right.parent = min;
          }
        transplant(deleteNode, min);
        min.Left = deleteNode.Left;
        min.Left.parent = min;
        }
      }
                     

                     //交换子树,将node2 移动至node1的位置。
      private void transplant(Node node1,Node node2) {
        if(node1.parent==null) {
          this.Root = node2;
        }else if(node1==node1.parent.Left) {
          node1.parent.Left = node2;
        }else {
          node1.parent.Right= node2;
        }
        if(node2!=null) {
          node2.parent = node1.parent;
        }
      }
                     

                     //查找方法
      public Node search(int value) {
        return searchNode(this.Root,value);
      }

      private Node searchNode(Node node,int key) {
        if(node==null || node.keyValue==key) {
          return node;
        }
        if(node.keyValue>key) {
          return this.searchNode(node.Left,key);
        }else {
          return this.searchNode(node.Right, key);
        }
      }

                     //插入方法
      public void insert(int value) {
        Node child = new Node(null, null, null, value);
        findRightPlace(this.Root,child);
      }

      private void findRightPlace(Node currentRoot,Node insertNode) {
        if(currentRoot!=null) {
            if(currentRoot.keyValue>insertNode.keyValue) {
              if(currentRoot.Left==null) {
                currentRoot.Left = insertNode;
                insertNode.parent = currentRoot;
              }else {
                findRightPlace(currentRoot.Left,insertNode);
                   }
            }else {
              if(currentRoot.Right==null) {
                currentRoot.Right = insertNode;
                insertNode.parent = currentRoot;
              }else {
                findRightPlace(currentRoot.Right,insertNode);
              }
            }
        }else {
            this.Root = insertNode;
        }
      }
                     

                     //查找最大
      public int findMax() {
        return max(this.Root)==null?-1:max(this.Root).keyValue;
      }

      private Node max(Node node) {
        if(node!=null) {
          if(node.Right!=null) {
            return max(node.Right);
          }else {
            return node;
          }
        }else {
          return null;
        }
      }
                     

                     //查找最小
      public int findMin() {
        return min(this.Root)==null?-1:min(this.Root).keyValue;
      }

      private Node min(Node node) {
        if(node!=null) {
          if(node.Left!=null) {
            return min(node.Left);
          }else {
            return node;
          }
        }else {
          return null;
        }
      }
                     

                     //后序遍历
      public void after() {
        afterShow(this.Root);
      }

      private void afterShow(Node node) {
        if(node!=null) {
          afterShow(node.Left);
          afterShow(node.Right);
          System.out.println(node.keyValue);
        }
      }

                     //中序遍历
      public void mid() {
        midShow(this.Root);
      }

      private void midShow(Node node) {
        if(node!=null) {
          midShow(node.Left);
          System.out.println(node.keyValue);
          midShow(node.Right);
        }
      }

                     //前序遍历
      public void ahead() {
        aheadShow(this.Root);
      }

      private void aheadShow(Node node) {
        if(node!=null) {
          System.out.println(node.keyValue);
          aheadShow(node.Left);
          aheadShow(node.Right);
        }
}

 参考资料 《算法导论》第三版

以上是关于二叉搜索树 思想 JAVA实现的主要内容,如果未能解决你的问题,请参考以下文章

二叉搜索树 - Java 实现

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

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

数据结构-PHP 实现二分搜索树

Java实现:二叉搜索树(Binary Search Tree)

Java实现二叉搜索树