什么是二叉搜索树？

二叉搜索树也叫做二叉排序树、二叉查找树，它有以下性质：

  1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
  2. 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
  3. 任意节点的左、右子树也分别为二叉查找树；
  4. 没有键值相等的节点。

二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低,为O(log n)。

基本操作

1.定义BST对象

  1. public class BST<E extends Comparable<E>> {
  3.     /**
  4.      * 定义节点
  5.      */
  6.     private class Node {
  7.         private E e;
  8.         private Node left;
  9.         private Node right;
  11.         Node(E e) {
  12.             this.e = e;
  13.         }
  14.     }
  16.     private Node root;
  17.     private int size;
  19.     /**
  20.      * 获取节点数
  21.      *
  22.      * @return
  23.      */
  24.     public int size() {
  25.         return this.size;
  26.     }
  27. }

2.添加节点

1.采用递归，终止条件是当前节点为null时，创建新的节点；

2.如果当前节点不为null，则通过比较插入值和当前节点值的大小，递归其左/右子节点。


  2. public void add(E element){
  3.     root = add(root, element);
  4. }
  6. private void _add(Node node, E element){
  7.     if(node == null){
  8.         size++;
  9.         return new Node(element);
  10.     }
  12.     if(element.compareTo(node.e) > 0){
  13.         node.right = _add(node.right, element);
  14.     }else if(element.compareTo(node.e) < 0){
  15.         node.left = _add(node.left, element);
  16.     }
  18.     return node;
  19. }

3.查询节点

1.通过比较当前节点值的大小，递归查找左/右子节点。


  2. public boolean contains(E element){
  3.     return _contains(root, element);
  4. }
  6. private boolean _contains(Node node,E element){
  7.     if(node == null) return false;
  9.     if(element.compareTo(node.e) == 0){
  10.         return true;
  11.     }else if(element.compareTo(node.e) > 0){
  12.         return _contains(node.right, element);
  13.     }else{
  14.         return _contains(node.left, element);
  15.     }
  17.     return false;
  18. }

4.打印二叉树

1.通过递增树的深度dept，层级打印；

2.叶子节点通过##表示。


  2. public String toString(){
  3.     StringBuilder builder = new StringBuilder();
  4.     _toString(root, 0, builder);
  5.     return builder.toString();
  6. }
  8. private void _toString(Node node, int dept, StringBuilder builder){
  9.     if(int i=0; i<dept; i++){
  10.         builder.append("--");
  11.     }
  13.     if(node == null){
  14.         builder.append("##\n");
  15.         return;
  16.     }
  18.     builder.append(node.e).append("\n");
  19.     _toString(node.left, dept+1, builder);
  20.     _toString(right, dept+1, builder);
  21. }

测试运行


  2. public static void main(String[] args) {
  4.         BST<Integer> bst = new BST<>();
  6.         bst.add(30);
  7.         bst.add(10);
  8.         bst.add(22);
  9.         bst.add(50);
  10.         bst.add(18);
  11.         bst.add(34);
  12.         bst.add(5);
  14.         System.out.println(bst);
  15.     }

输出结果为：

  1. 30
  2. --10
  3. ----5
  4. ------##
  5. ------##
  6. ----22
  7. ------18
  8. --------##
  9. --------##
  10. ------##
  11. --50
  12. ----34
  13. ------##
  14. ------##
  15. ----##

遍历操作

二叉树的遍历分为：前序遍历、中序遍历、后序遍历，

这里的前中后指的是父节点的顺序，所以三种遍历的顺序是：

  • 前序遍历（父-左-右）
  • 中序遍历 （左-父-右）
  • 后序遍历 （左-右-父）

1.前序遍历

1.递归遍历，终止条件是当前节点为null；

2.先遍历输出父节点，再遍历左、右子节点


  2. public void preOrder(){
  3.     StringBuilder builer = new StringBuilder();
  4.     _preOrder(root, builer);
  5.     System.out.println(builer.toString);
  6. }
  8. private void _preOrder(Node node,StringBuilder builder){
  9.     if(node == null) return;
  11.     builder.append(node.e).append(" ");
  12.     _preOrder(node.left, builder);
  13.     _preOrder(node.right, builder);
  14. }

2.前序遍历2（非递归）

1.借助栈，首先将节点放入栈中，开始遍历栈；

2.遍历取出节点后再将其右子节点和左子节点放入压入栈中；


  2. public void preOrder2(){
  3.     StringBuilder builder = new StringBuilder();
  5.     Stack<Node> stack = new Stack();
  6.     stack.push(root);
  8.     while(!stack.isEmpty()){
  9.         Node node = stack.pop();
  10.         if(node == null) continue;
  12.         builder.append(node.e).append(" ");
  13.         stack.push(node.right);
  14.         stack.push(node.left);
  15.     }
  17.     System.out.println(builder.toString());
  18. }

3.中序遍历

1.同前序遍历，只是输出的顺序不同


  2. public void inOrder(){
  3.     StringBuilder builer = new StringBuilder();
  4.     _inOrder(root, builer);
  5.     System.out.println(builer.toString);
  6. }
  8. private void _inOrder(Node node,StringBuilder builder){
  9.     if(node == null) return;
  11.     _inOrder(node.left, builder);
  12.     builder.append(node.e).append(" ");
  13.     _inOrder(node.right, builder);
  14. }

输入你会发现，二叉搜索树的中序遍历的结果是有序的（从小到大）。

4.后序遍历

1.同前序遍历，只是输出的顺序不同


  2. public void postOrder(){
  3.     StringBuilder builer = new StringBuilder();
  4.     _postOrder(root, builer);
  5.     System.out.println(builer.toString);
  6. }
  8. private void _postOrder(Node node,StringBuilder builder){
  9.     if(node == null) return;
  11.     _postOrder(node.left, builder);
  12.     _postOrder(node.right, builder);
  13.     builder.append(node.e).append(" ");
  14. }

5.层序遍历

层序遍历指的是从上到下，从左到右一层层遍历，其遍历方法和上面的前序遍历类似，只是这里借助的是队列；

1.需要借助队列，首选将根节点入队，开始遍历队列；

2.如果当前节点不为null，则将其左子节点和右子节点入队，继续遍历；


  2. public void levelOrder() {
  3.         StringBuilder builder = new StringBuilder();
  5.         Queue<Node> queue = new LinkedList<>();
  6.         queue.offer(root);
  8.         while (!queue.isEmpty()) {
  9.             Node node = queue.poll();
  11.             if (node == null) continue;
  13.             builder.append(node.e).append(" ");
  15.             queue.offer(node.left);
  16.             queue.offer(node.right);
  17.         }
  19.         System.out.println(builder.toString());
  20.     }

删除

1.删除最小/最大节点

以删除最小为例，最小节点一定是树的最左边的那个：

1.因为删除的节点可能是遍历的当前节点，所以需要通过return的形式返回节点；

2.判断左子节点是否为null：

如果不为null则递归遍历左子节点；

如果为null则要删除的是当前节点，要把它的右节点返回；

  1. public Node removeMinimum() {
  2.         root = _removeMinimun(root);
  3.         return root;
  4.     }
  6. private Node _removeMinimun(Node node) {
  7.     if (node == null) return null;
  9.     if (node.left == null) {
  10.         //如果左子节点为null，则把右子节点返回
  11.         Node tmp = node.right;
  12.         node.right = null;
  13.         size--;
  14.         return tmp;
  15.     }
  17.     node.left = _removeMinimun(node.left);
  18.     return node;
  19. }

2.删除任意节点

分三种情况：

  • 如果该节点没有左子节点：返回其右子节点；
  • 如果该节点没有右子节点：返回其左子节点；
  • 如果该节点同时拥有左右子节点：

节点的后继节点是大于它并最接近它的那个节点，也就是该节点的右子树中最小的节点，就是其右子树中最左边的那个，如下图中15的后继节点是17。

1.需要找到其后继节点；

2.将后继节点删除；

3.将后继节点的左子树等于该节点的左子树；

4.将后继节点的右子树等于该节点的右子树删除后继节点返回的树。


  2.     /**
  3.      * 删除任意节点，并返回删除后的根节点
  4.      *
  5.      * @param e
  6.      * @return
  7.      */
  8.     public void removeNode(E e) {
  9.         root = _removeNode(root, e);
  10.     }
  12.     private Node _removeNode(Node node, E e) {
  13.         if (node == null) return null;
  15.         if (e.compareTo(node.e) < 0) {
  16.             node.left = _removeNode(node.left, e);
  17.         } else if (e.compareTo(node.e) > 0) {
  18.             node.right = _removeNode(node.right, e);
  19.         } else {
  20.             //1.查找到对应的节点
  22.             //2.左子树为空的情况，直接把右子树返回
  23.             if (node.left == null) {
  24.                 Node right = node.right;
  25.                 node.right = null;
  26.                 return right;
  27.             }
  29.             //3.右子树为空的情况，直接把左子树放回
  30.             if (node.right == null) {
  31.                 Node left = node.left;
  32.                 node.left = null;
  33.                 return left;
  34.             }
  36.             //4.找到后继节点（右子树中最小的节点）
  37.             Node successor = _mininum(node.right);
  38.             //5.将右子树中最小的节点删除
  39.             successor.right = _removeMinimun(node.right);
  40.             //6.将节点的左子树等于后继节点的左子树
  41.             successor.left = node.left;
  43.             node.left = node.right = null;
  45.             //7.返回后继节点
  46.             return successor;
  47.         }
  49.         return node;
  50.     }
  52.     /**
  53.      * 查找最小的节点
  54.      *
  55.      * @param node
  56.      * @return
  57.      */
  58.     private Node _mininum(Node node) {
  59.         if (node == null) return null;
  61.         if (node.left != null) {
  62.             return _mininum(node.left);
  63.         }
  65.         return node;
  66.     }

完整代码BST.java

  1. import java.util.LinkedList;
  2. import java.util.Queue;
  3. import java.util.Stack;
  5. /**
  6.  * Binary Search Tree
  7.  *
  8.  * @param <E>
  9.  */
  10. public class BST<E extends Comparable<E>> {
  12.     /**
  13.      * 定义节点
  14.      */
  15.     private class Node {
  16.         private E e;
  17.         private Node left;
  18.         private Node right;
  20.         Node(E e) {
  21.             this.e = e;
  22.         }
  23.     }
  25.     private Node root;
  26.     private int size;
  28.     /**
  29.      * 获取节点数
  30.      *
  31.      * @return
  32.      */
  33.     public int size() {
  34.         return this.size;
  35.     }
  37.     /**
  38.      * 添加节点
  39.      *
  40.      * @param element
  41.      */
  42.     public void add(E element) {
  44.         root = add(root, element);
  45.     }
  47.     private Node add(Node node, E element) {
  49.         if (node == null) {
  50.             size++;
  51.             return new Node(element);
  52.         }
  54.         if (element.compareTo(node.e) > 0) {
  55.             node.right = add(node.right, element);
  56.         } else if (element.compareTo(node.e) < 0) {
  57.             node.left = add(node.left, element);
  58.         }
  60.         return node;
  61.     }
  63.     /**
  64.      * 是否含有节点
  65.      *
  66.      * @param element
  67.      * @return
  68.      */
  69.     public boolean contains(E element) {
  71.         return contains(root, element);
  72.     }
  74.     private boolean contains(Node node, E element) {
  75.         if (node == null) return false;
  77.         if (element.equals(node.e)) return true;
  79.         if (element.compareTo(node.e) < 0) {
  80.             return contains(node.left, element);
  81.         } else {
  82.             return contains(node.right, element);
  83.         }
  85.     }
  87.     @Override
  88.     public String toString() {
  89.         StringBuilder builder = new StringBuilder();
  91.         toString(root, 0, builder);
  93.         return builder.toString();
  94.     }
  96.     private void toString(Node node, int dept, StringBuilder builder) {
  97.         for (int i = 0; i < dept; i++) {
  98.             builder.append("--");
  99.         }
  101.         if (node == null) {
  102.             builder.append("##\n");
  103.             return;
  104.         }
  106.         builder.append(node.e);
  107.         builder.append("\n");
  109.         toString(node.left, dept + 1, builder);
  110.         toString(node.right, dept + 1, builder);
  111.     }
  113.     /**
  114.      * 前序遍历
  115.      */
  116.     public void preOrder() {
  117.         StringBuilder builder = new StringBuilder();
  119.         preOrder(root, builder);
  121.         System.out.println(builder.toString());
  122.     }
  124.     private void preOrder(Node root, StringBuilder builder) {
  125.         if (root == null) return;
  127.         builder.append(root.e).append(" ");
  128.         preOrder(root.left, builder);
  129.         preOrder(root.right, builder);
  130.     }
  132.     /**
  133.      * 前序遍历（非递归）
  134.      */
  135.     public void preOrderTraverse2() {
  136.         StringBuilder builder = new StringBuilder();
  138.         Stack<Node> stack = new Stack<>();
  139.         stack.push(root);
  141.         while (!stack.isEmpty()) {
  142.             Node node = stack.pop();
  143.             if (node == null) continue;
  145.             builder.append(node.e).append(" ");
  147.             stack.push(node.right);
  148.             stack.push(node.left);
  149.         }
  151.         System.out.println(builder.toString());
  152.     }
  154.     /**
  155.      * 中序遍历
  156.      */
  157.     public void inOrder() {
  158.         StringBuilder builder = new StringBuilder();
  160.         inOrder(root, builder);
  161.         System.out.println(builder.toString());
  162.     }
  164.     private void inOrder(Node root, StringBuilder builder) {
  165.         if (root == null) return;
  167.         inOrder(root.left, builder);
  168.         builder.append(root.e).append(" ");
  169.         inOrder(root.right, builder);
  170.     }
  172.     /**
  173.      * 后序遍历
  174.      */
  175.     public void postOrder() {
  176.         StringBuilder builder = new StringBuilder();
  178.         postOrder(root, builder);
  179.         System.out.println(builder.toString());
  180.     }
  182.     private void postOrder(Node root, StringBuilder builder) {
  183.         if (root == null) return;
  185.         postOrder(root.left, builder);
  186.         postOrder(root.right, builder);
  187.         builder.append(root.e).append(" ");
  188.     }
  190.     /**
  191.      * 层序遍历
  192.      */
  193.     public void levelOrder() {
  194.         StringBuilder builder = new StringBuilder();
  196.         Queue<Node> queue = new LinkedList<>();
  197.         queue.offer(root);
  199.         while (!queue.isEmpty()) {
  200.             Node node = queue.poll();
  202.             if (node == null) continue;
  204.             builder.append(node.e).append(" ");
  206.             queue.offer(node.left);
  207.             queue.offer(node.right);
  208.         }
  210.         System.out.println(builder.toString());
  211.     }
  213.     /**
  214.      * 删除最小节点,返回删除后的根节点
  215.      */
  216.     public Node removeMinimum() {
  217.         root = _removeMinimun(root);
  218.         return root;
  219.     }
  221.     private Node _removeMinimun(Node node) {
  222.         if (node == null) return null;
  224.         if (node.left == null) {
  225.             //如果左子节点为null，则把右子节点返回
  226.             Node tmp = node.right;
  227.             node.right = null;
  228.             size--;
  229.             return tmp;
  230.         }
  232.         node.left = _removeMinimun(node.left);
  233.         return node;
  234.     }
  236.     /**
  237.      * 删除最大节点，,返回删除后的根节点
  238.      *
  239.      * @return
  240.      */
  241.     public Node removeMaximum() {
  242.         root = _removeMaxinum(root);
  243.         return root;
  244.     }
  246.     private Node _removeMaxinum(Node node) {
  247.         if (node == null) return null;
  249.         if (node.right == null) {
  250.             Node tmp = node.left;
  251.             node.left = null;
  252.             size--;
  253.             return tmp;
  254.         }
  256.         node.right = _removeMaxinum(node.right);
  257.         return node;
  258.     }
  260.     /**
  261.      * 删除任意节点，并返回删除后的根节点
  262.      *
  263.      * @param e
  264.      * @return
  265.      */
  266.     public void removeNode(E e) {
  267.         root = _removeNode(root, e);
  268.     }
  270.     private Node _removeNode(Node node, E e) {
  271.         if (node == null) return null;
  273.         if (e.compareTo(node.e) < 0) {
  274.             node.left = _removeNode(node.left, e);
  275.         } else if (e.compareTo(node.e) > 0) {
  276.             node.right = _removeNode(node.right, e);
  277.         } else {
  278.             //1.查找到对应的节点
  280.             //2.左子树为空的情况，直接把右子树返回
  281.             if (node.left == null) {
  282.                 Node right = node.right;
  283.                 node.right = null;
  284.                 return right;
  285.             }
  287.             //3.右子树为空的情况，直接把左子树放回
  288.             if (node.right == null) {
  289.                 Node left = node.left;
  290.                 node.left = null;
  291.                 return left;
  292.             }
  294.             //4.找到后继节点（右子树中最小的节点）
  295.             Node successor = _mininum(node.right);
  296.             //5.将右子树中最小的节点删除
  297.             successor.right = _removeMinimun(node.right);
  298.             //6.将节点的左子树等于后继节点的左子树
  299.             successor.left = node.left;
  301.             node.left = node.right = null;
  303.             //7.返回后继节点
  304.             return successor;
  305.         }
  307.         return node;
  308.     }
  310.     /**
  311.      * 查找最小的节点
  312.      *
  313.      * @param node
  314.      * @return
  315.      */
  316.     private Node _mininum(Node node) {
  317.         if (node == null) return null;
  319.         if (node.left != null) {
  320.             return _mininum(node.left);
  321.         }
  323.         return node;
  324.     }
  326. }

二叉搜索树（BST）基本操作的更多相关文章

  1. C++版 - 剑指offer 面试题24：二叉搜索树BST的后序遍历序列(的判断) 题解

    剑指offer 面试题24:二叉搜索树的后序遍历序列(的判断) 题目:输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果.如果是则返回true.否则返回false.假设输入的数组的任意两个 ...

  2. 数据结构-二叉搜索树(BST binary search tree)

    本文由@呆代待殆原创,转载请注明出处:http://www.cnblogs.com/coffeeSS/ 二叉搜索树简介 顾名思义,二叉搜索树是以一棵二叉树来组织的,这样的一棵树可以用一个链表数据结构来 ...

  3. 萌新笔记之二叉搜索树(BST)

    前言,以前搞过线段树,二叉树觉得也就那样= =.然后数据结构的课也没怎么听过,然后下周期中考... 本来以为今天英语考完可以好好搞ACM了,然后这个数据结构期中考感觉会丢人,还是好好学习一波. 二叉搜 ...

  4. 给定一个二叉搜索树(BST)，找到树中第 K 小的节点

    问题:给定一个二叉搜索树(BST),找到树中第 K 小的节点. 出题人:阿里巴巴出题专家:文景/阿里云 CDN 资深技术专家. 考察点: 1. 基础数据结构的理解和编码能力 2.  递归使用 参考答案 ...

  5. 二叉搜索树(BST)学习笔记

    BST调了一天,最后遍历参数错了,没药救了-- 本文所有代码均使用数组+结构体,不使用指针! 前言--BFS是啥 BST 二叉搜索树是基于二叉树的一种树,一种特殊的二叉树. 二叉搜索树要么是一颗空树, ...

  6. 看动画学算法之:二叉搜索树BST

    目录 简介 BST的基本性质 BST的构建 BST的搜索 BST的插入 BST的删除 简介 树是类似于链表的数据结构,和链表的线性结构不同的是,树是具有层次结构的非线性的数据结构. 树是由很多个节点组 ...

  7. 在二叉搜索树(BST)中查找第K个大的结点之非递归实现

    一个被广泛使用的面试题: 给定一个二叉搜索树,请找出其中的第K个大的结点. PS:我第一次在面试的时候被问到这个问题而且让我直接在白纸上写的时候,直接蒙圈了,因为没有刷题准备,所以就会有伤害.(面完的 ...

  8. 二叉搜索树 (BST) 的创建以及遍历

    二叉搜索树(Binary Search Tree) : 属于二叉树,其中每个节点都含有一个可以比较的键(如需要可以在键上关联值), 且每个节点的键都大于其左子树中的任意节点而小于右子树的任意节点的键. ...

  9. [LeetCode] Convert BST to Greater Tree 将二叉搜索树BST转为较大树

    Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original B ...

  10. 二叉搜索树(BST)

    (第一段日常扯蛋,大家不要看)这几天就要回家了,osgearth暂时也不想弄了,毕竟不是几天就能弄出来的,所以打算过完年回来再弄.这几天闲着也是闲着,就掏出了之前买的算法导论看了看,把二叉搜索树实现了 ...

随机推荐

  1. 分布式文件管理系统HDFS

    Hadoop 分布式文件管理系统HDFS可以部署在廉价硬件之上,能够高容错. 可靠地存储海量数据(可以达到TB甚至PB级),它还可以和Yam中的MapReduce 编程模型很好地结合,为应用程序提供高 ...

  2. bootstrap如何去除自带的样式----导航栏中的菜单实现平滑的过渡到对应的菜单区域-------动态跟换模态框中的内容

    问题1:如何去除bootstap中css中自带的overflow:hidden这个样式 今天遇见在bootstap中轮播图上的  附带图  片不能够显示出来,图片始终有一部分的高度  被隐藏了 后来通 ...

  3. Tensorflow之多元线性回归问题（以波士顿房价预测为例）

    一.根据波士顿房价信息进行预测,多元线性回归+特征数据归一化 #读取数据 %matplotlib notebook import tensorflow as tf import matplotlib. ...

  4. day3_7.1

    1.python的注释 python中为了使代码更容易被人看懂,提高团队开发效率,可使用注释.代码中的注释不加入编译中. 注释有单行注释,如 #这是一段注释 和多行注释: ''' 这是一行注释 ''' ...

  5. 【Ribbon篇四】自定义负载均衡策略（4）

    官方文档特别指出:自定义的负载均衡配置类不能放在 @componentScan 所扫描的当前包下及其子包下,否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享,也就是说我们达不到特殊化定制 ...

  6. CSP2019-S1 游记

    估分 83 分qwq 上午照常起床,先跑去学校考了一场化学(黑人问号),然后8:30从学校开溜. 8:50到考点,发现淮安S组只有两个考场... 在考点外遇到一群 金湖中学 的. 不怕了,有水军帮忙垫 ...

  7. svg 画地图

    下载一个svgDeveloper软件,破解版下载     1.首先找一张地图作为绘制模板;(当然你也可以自己画,不准确怪我咯!)       2.新建svg文件:File --> New --& ...

  8. 【oracle】获取字符串长度

    lengthb(string)计算string所占的字节长度:返回字符串的长度,单位是字节 length(string)计算string所占的字符长度:返回字符串的长度,单位是字符

  9. Bootstrap分页查询

    前台方法: function show() { $('#reportTable').bootstrapTable({ method: 'get', url: "@Url.Action(&qu ...

  10. mac使用技巧和快捷键

    mac快捷键 shift+command+delete 清除缓存 shift+command+. 查看隐藏文件 ctrl+空格 切换输入法 shift+option+F11/F12 精细调节声音 fn ...