查找是指在一批记录中找出满足指定条件的某一记录的过程,例如在数组{ 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 }中查找数字15,实现代码很简单:

  1. int key = 15;
  2. int[] datas = new int[] { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
  3. for(int i = 0; i < datas.length; i++) {
  4. if(datas[i] == key) {
  5. System.out.println("找到了, 共查找" + (i + 1) + "次");
  6. break;
  7. }
  8. }

但是查找效率并不稳定,如果查找8,只需要比较一次,查找15则需要比较15次。如果数组扩大到1亿个数,而查找的数字恰好排在最后,查找则变得非常低效。

更好的查找方式是使用二叉搜索树,首先用数组构建二叉树,如下图:

二叉树的相关基础知识可参考:Java与算法之(7) - 完全二叉树

注意上面这棵二叉树的特点,每个左子节点的值都比父节点小,每个右子节点的值都比父节点大。满足这个条件的二叉树称为二叉搜索树(Binary Search Tree),也叫二叉排序树(Binary Sorting Tree)。

根据这个特性,可以得出查找的规律。以查找15为例,从根节点8开始比较,因15>8,(如果存在)则一定在8的右子树内;与右子树12比较,因15>12,(如果存在)则一定在12的右子树内;与14比较。。。与15比较,找到目标。

如果查找5,则依次比较8、4、6、5。

在这棵树中,查找任何一个数字,最多需要比较4次(约log2(15))。介绍查找方法之前,先看如何构建这棵树。

1 插入节点

用数据描述这棵树,首选需要描述节点。用一个类来表示,每个节点包括本身的值及左右两个子节点的指针。

  1. private static class Node {
  2. Node leftChild;
  3. Node rightChild;
  4. int data;
  5. public Node(int data) {
  6. this.data = data;
  7. }
  8. }

树由节点组成,一个一个节点加进去,树叶逐渐变得枝繁叶茂。构建树的过程可以分解成不断重复的插入节点行为。

第一个加入的节点做为根节点,以后加入节点的操作和前面所述的查询过程一样,从根开始比较,如果小于则和左子节点比较,如果大于则和右子节点比较,不断重复这个过程直到到达叶子节点。比叶子节点小则做为叶子节点的左子节点,大则做为右子节点。

构建过程如下:

这个过程的逻辑是一直向下寻找,直到没有子节点为止。整个过程适合用递归的方式,主要代码如下:

  1. public void add(int key) {
  2. if(root == null) {
  3. root = new Node(key);
  4. return;
  5. }
  6. addNode(root, new Node(key));
  7. }
  8. private void addNode(Node parent, Node child) {
  9. if(child.data == parent.data) {
  10. return;
  11. }
  12. if(child.data < parent.data) {
  13. if(parent.leftChild != null) {
  14. addNode(parent.leftChild, child);
  15. } else {
  16. parent.leftChild = child;
  17. }
  18. } else {
  19. if(parent.rightChild != null) {
  20. addNode(parent.rightChild, child);
  21. } else {
  22. parent.rightChild = child;
  23. }
  24. }
  25. }

2 查找节点

查找一个节点和插入一个节点的流程很相似,但是结果相反。插入节点是一直向下寻找,找到则插入失败,找不到则做为叶子节点加入树中。查找节点是一直向下寻找,找到则成功返回,找不到则查找失败。

代码如下:

  1. public void search(int key) {
  2. this.steps = 0;
  3. Node node = searchNode(root, key);
  4. if(node == null) {
  5. System.out.println("共查找" + this.steps + "次, 未找到" + key);
  6. } else {
  7. System.out.println("共查找" + this.steps + "次, 搜索到" + key);
  8. }
  9. }
  10. private Node searchNode(Node from, int key) {
  11. this.steps++;
  12. if(from == null || key == from.data) {
  13. return from;
  14. } else if(key > from.data) {
  15. return searchNode(from.rightChild, key);
  16. } else {
  17. return searchNode(from.leftChild, key);
  18. }
  19. }

3 删除节点

在二叉搜索树中删除一个节点后,需要调整二叉树的结构,使其仍然保持二叉搜索树的特点。以被删除节点拥有子节点的情况,分三种情况考虑。见下图:

  • 15节点左右子节点都没有,删除时直接把父节点14的右子节点设置为null即可
  • 2节点没有右子节点,删除时需要把左子树连接回树中,即把4的左子节点指向1;6节点没有左子节点,删除时需要把右子树连接回书中,即把4的右子节点指向7
  • 8节点同时拥有左右子节点,删除规则是先找到右子节点即12,然后递归12节点的左子节点,直到叶子节点,这张图中将找到9。设置8节点的值为9,并删除9节点。

按这个规则推导其他数字删除的步骤:

删除4,先找到6,6没有左子节点,查找结束,将4节点的值设置为6,按规则2删除6节点。

删除12,先找到14,递归左子节点找到13,设置12节点的值为13,删除13。

二叉搜索数完整代码如下:

  1. public class BinarySearchTree {
  2. private Node root;
  3. private int steps;
  4. /**
  5. * 插入节点
  6. * @param key
  7. */
  8. public void add(int key) {
  9. if(root == null) {
  10. root = new Node(key);
  11. return;
  12. }
  13. addNode(root, new Node(key));
  14. }
  15. private void addNode(Node parent, Node child) {
  16. if(child.data == parent.data) {
  17. return;
  18. }
  19. if(child.data < parent.data) {
  20. if(parent.leftChild != null) {
  21. addNode(parent.leftChild, child);
  22. } else {
  23. parent.leftChild = child;
  24. }
  25. } else {
  26. if(parent.rightChild != null) {
  27. addNode(parent.rightChild, child);
  28. } else {
  29. parent.rightChild = child;
  30. }
  31. }
  32. }
  33. /**
  34. * 查找节点
  35. * @param key
  36. */
  37. public void search(int key) {
  38. this.steps = 0;
  39. Node node = searchNode(root, key);
  40. if(node == null) {
  41. System.out.println("共查找" + this.steps + "次, 未找到" + key);
  42. } else {
  43. System.out.println("共查找" + this.steps + "次, 搜索到" + key);
  44. }
  45. }
  46. private Node searchNode(Node from, int key) {
  47. this.steps++;
  48. if(from == null || key == from.data) {
  49. return from;
  50. } else if(key > from.data) {
  51. return searchNode(from.rightChild, key);
  52. } else {
  53. return searchNode(from.leftChild, key);
  54. }
  55. }
  56. /**
  57. * 删除节点
  58. * @param key
  59. */
  60. public void delete(int key) {
  61. Node child = root;
  62. Node parent = child;
  63. boolean isLeftChild = true;
  64. while(child != null) {
  65. if(child.data == key) {
  66. deleteNode(parent, child, isLeftChild);
  67. child = null;
  68. } else if(key < child.data) {
  69. isLeftChild = true;
  70. parent = child;
  71. child = child.leftChild;
  72. } else {
  73. isLeftChild = false;
  74. parent = child;
  75. child = child.rightChild;
  76. }
  77. }
  78. }
  79. private void deleteNode(Node parent, Node child, boolean isLeftChild) {
  80. if(child.leftChild == null && child.rightChild == null) {
  81. if(isLeftChild) {
  82. parent.leftChild = null;
  83. } else {
  84. parent.rightChild = null;
  85. }
  86. } else if(child.leftChild == null) {
  87. if(isLeftChild) {
  88. parent.leftChild = child.rightChild;
  89. } else {
  90. parent.rightChild = child.rightChild;
  91. }
  92. } else if(child.rightChild == null) {
  93. if(isLeftChild) {
  94. parent.leftChild = child.leftChild;
  95. } else {
  96. parent.rightChild = child.leftChild;
  97. }
  98. } else {
  99. Node leaf = child.rightChild;
  100. parent = child;
  101. while(leaf.leftChild != null) {
  102. parent = leaf;
  103. leaf = leaf.leftChild;
  104. }
  105. child.data = leaf.data;
  106. if(parent != child)
  107. parent.leftChild = leaf.leftChild;
  108. else
  109. parent.rightChild = leaf.rightChild;
  110. }
  111. }
  112. /**
  113. * 中序遍历二叉搜索树, 结果是从小到大排列的
  114. * @param node
  115. */
  116. public void inOrder(Node node) {
  117. if(node == null) {
  118. return;
  119. }
  120. inOrder(node.leftChild);
  121. System.out.print(node.data + " ");
  122. inOrder(node.rightChild);
  123. }
  124. private static class Node {
  125. Node leftChild;
  126. Node rightChild;
  127. int data;
  128. public Node(int data) {
  129. this.data = data;
  130. }
  131. }
  132. public static void main(String[] args) {
  133. int[] datas = new int[] { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
  134. BinarySearchTree bsTree = new BinarySearchTree();
  135. for(int i = 0; i < datas.length; i++) {
  136. bsTree.add(datas[i]);
  137. }
  138. System.out.print("中序遍历");
  139. bsTree.inOrder(bsTree.root);
  140. System.out.println();
  141. bsTree.search(8);
  142. bsTree.search(12);
  143. bsTree.search(15);
  144. System.out.println("删除节点8");
  145. bsTree.delete(8);
  146. System.out.print("中序遍历");
  147. bsTree.inOrder(bsTree.root);
  148. System.out.println();
  149. bsTree.search(8);
  150. }
  151. }

运行结果:

  1. 中序遍历1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
  2. 共查找1次, 搜索到8
  3. 共查找2次, 搜索到12
  4. 共查找4次, 搜索到15
  5. 删除节点8
  6. 中序遍历1 2 3 4 5 6 7 9 10 11 12 13 14 15
  7. 共查找5次, 未找到8

本例中的二叉树结构是一种理想情况,如果对数组{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}使用上面的方法构建二叉搜索树,动手画一下就可以发现最终得到的仍然是一个链表,查找15需要比较15次。

这棵树根的左右严重失衡,左侧一个子节点都没有,而右侧的深度为15。为了保证查找的效率,需要对这棵树做优化,让整棵树保持一定的平衡,这就是下一篇的主角:平衡二叉搜索树。

Java与算法之(13) - 二叉搜索树的更多相关文章

  1. 自己动手实现java数据结构(六)二叉搜索树

    1.二叉搜索树介绍 前面我们已经介绍过了向量和链表.有序向量可以以二分查找的方式高效的查找特定元素,而缺点是插入删除的效率较低(需要整体移动内部元素):链表的优点在于插入,删除元素时效率较高,但由于不 ...

  2. Java实现 LeetCode 538 把二叉搜索树转换为累加树(遍历树)

    538. 把二叉搜索树转换为累加树 给定一个二叉搜索树(Binary Search Tree),把它转换成为累加树(Greater Tree),使得每个节点的值是原来的节点值加上所有大于它的节点值之和 ...

  3. 看动画学算法之:平衡二叉搜索树AVL Tree

    目录 简介 AVL的特性 AVL的构建 AVL的搜索 AVL的插入 AVL的删除 简介 平衡二叉搜索树是一种特殊的二叉搜索树.为什么会有平衡二叉搜索树呢? 考虑一下二叉搜索树的特殊情况,如果一个二叉搜 ...

  4. Java实现 LeetCode 669 修剪二叉搜索树(遍历树)

    669. 修剪二叉搜索树 给定一个二叉搜索树,同时给定最小边界L 和最大边界 R.通过修剪二叉搜索树,使得所有节点的值在[L, R]中 (R>=L) .你可能需要改变树的根节点,所以结果应当返回 ...

  5. Java实现 LeetCode 99 恢复二叉搜索树

    99. 恢复二叉搜索树 二叉搜索树中的两个节点被错误地交换. 请在不改变其结构的情况下,恢复这棵树. 示例 1: 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,nu ...

  6. Java实现 LeetCode 98 验证二叉搜索树

    98. 验证二叉搜索树 给定一个二叉树,判断其是否是一个有效的二叉搜索树. 假设一个二叉搜索树具有如下特征: 节点的左子树只包含小于当前节点的数. 节点的右子树只包含大于当前节点的数. 所有左子树和右 ...

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

    @ 目录 1.二叉搜索树 1.1. 基本概念 1.2.树的节点(BinaryNode) 1.3.构造器和成员变量 1.3.公共方法(public method) 1.4.比较函数 1.5.contai ...

  8. JS递归及二叉搜索树的移除节点

    1递归含义:在某时某刻某个条件下调用包含自己的函数 2:注意点:⑴递归过程中一定要加限制条件,要不然会陷入死循环: 死循环eg: function f(someP){ f(somP); } f(4); ...

  9. 【算法与数据结构】二叉搜索树的Java实现

    为了更加深入了解二叉搜索树,博主自己用Java写了个二叉搜索树,有兴趣的同学可以一起探讨探讨. 首先,二叉搜索树是啥?它有什么用呢? 二叉搜索树, 也称二叉排序树,它的每个节点的数据结构为1个父节点指 ...

随机推荐

  1. Struts2框架(3)---Action类的3种书写方式

    Action类的3种书写方式 本文主要写有关写Action类的3种书写方式: (1)第一种 Action可以是POJO (简单模型对象)  不需要继承任何父类 也不需要实现任何接口 (2)实现Acti ...

  2. spring boot https --restful接口篇

    我们写的接口默认都是http形式的,不过我们的接口很容易被人抓包,而且一抓全是明文的挺尴尬的 spring boot配置https生成证书大的方向有3种: 1.利用keytool自己生成证书 2.从免 ...

  3. JavaScript中函数function fun(){}和 var fun=function(){}的区别

    function fun(){} 和 var fun=function(){}的区别 标题有点长···· 废话少说,其实他们的主要区别就是"函数声明的提前行为". var fun= ...

  4. 55、js对象

    在python中我们学习了面向对象,javascript也是一门面向对象语言,在JavaScript中除了null和undefined以外其他的数据类型都被定义成了对象. JavaScript的对象简 ...

  5. iOS APP之间到跳转,以及热门应用,手机自带到应用跳转

    应用之间的跳转 在第一个APP中,做如下操作:1.在info.plist文件中的"信息属性列表"下添加一项:"URL类型"; 2.点开"URL类型&q ...

  6. Python学习日记:day5-------dict字典

    #字典dict------->唯一的映射类型 1.数据类型的划分 数据类型划分为可变数据类型和不可变数据类型. 不可变数据类型:tupe(元组).bool.int.str           可 ...

  7. asp.net MVC分页

    .Net MVC  分页代码,分页的关键就是在于这几个参数pageIndex ,recordCount,pageSize ,下面是张林的网站做的一个简单的分页代码 效果如图 public class ...

  8. springBoot系列教程05:fastjson的集成、配置及使用

    springBoot自带的json用着不太习惯,已习惯了fastJSON,下面介绍下fastjson的配置 1. pom引入 <dependency> <groupId>com ...

  9. 浏览器中的user-agent的几种模式

    服务器一般会根据访问的浏览器进行识别,针对不同浏览器才用不同的网站样式及结构,也是通过这个信息判断用户使用的平台模式(手机,pc或平板) 识别为手机一般有这几个关键字: "Windows P ...

  10. [ZJOI2015]地震后的幻想乡

    题目传送门 SOL:不会积分的我瑟瑟发抖. 所以我选择状压DP. 我们有以下一个dp状态: f[S][i],S表示点集,i表示这个点集向外联了i条边. 那么答案就是f[(1<<n)-1][ ...