Java与算法之(13) - 二叉搜索树
2016-09-28 16:13
330 查看
查找是指在一批记录中找出满足指定条件的某一记录的过程,例如在数组{ 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 }中查找数字15,实现代码很简单:
更好的查找方式是使用二叉搜索树,首先用数组构建二叉树,如下图:
二叉树的相关基础知识可参考: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))。介绍查找方法之前,先看如何构建这棵树。
第一个加入的节点做为根节点,以后加入节点的操作和前面所述的查询过程一样,从根开始比较,如果小于则和左子节点比较,如果大于则和右子节点比较,不断重复这个过程直到到达叶子节点。比叶子节点小则做为叶子节点的左子节点,大则做为右子节点。
构建过程如下:
这个过程的逻辑是一直向下寻找,直到没有子节点为止。整个过程适合用递归的方式,主要代码如下:
代码如下:
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。
二叉搜索数完整代码如下:
运行结果:
这棵树根的左右严重失衡,左侧一个子节点都没有,而右侧的深度为15。为了保证查找的效率,需要对这棵树做优化,让整棵树保持一定的平衡,这就是下一篇的主角:平衡二叉搜索树。
int key = 15; int[] datas = new int[] { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 }; for(int i = 0; i < datas.length; i++) { if(datas[i] == key) { System.out.println("找到了, 共查找" + (i + 1) + "次"); break; } }但是查找效率并不稳定,如果查找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 插入节点
用数据描述这棵树,首选需要描述节点。用一个类来表示,每个节点包括本身的值及左右两个子节点的指针。private static class Node { Node leftChild; Node rightChild; int data; public Node(int data) { this.data = data; } }树由节点组成,一个一个节点加进去,树叶逐渐变得枝繁叶茂。构建树的过程可以分解成不断重复的插入节点行为。
第一个加入的节点做为根节点,以后加入节点的操作和前面所述的查询过程一样,从根开始比较,如果小于则和左子节点比较,如果大于则和右子节点比较,不断重复这个过程直到到达叶子节点。比叶子节点小则做为叶子节点的左子节点,大则做为右子节点。
构建过程如下:
这个过程的逻辑是一直向下寻找,直到没有子节点为止。整个过程适合用递归的方式,主要代码如下:
public void add(int key) { if(root == null) { root = new Node(key); return; } addNode(root, new Node(key)); } private void addNode(Node parent, Node child) { if(child.data == parent.data) { return; } if(child.data < parent.data) { if(parent.leftChild != null) { addNode(parent.leftChild, child); } else { parent.leftChild = child; } } else { if(parent.rightChild != null) { addNode(parent.rightChild, child); } else { parent.rightChild = child; } } }
2 查找节点
查找一个节点和插入一个节点的流程很相似,但是结果相反。插入节点是一直向下寻找,找到则插入失败,找不到则做为叶子节点加入树中。查找节点是一直向下寻找,找到则成功返回,找不到则查找失败。代码如下:
public void search(int key) { this.steps = 0; Node node = searchNode(root, key); if(node == null) { System.out.println("共查找" + this.steps + "次, 未找到" + key); } else { System.out.println("共查找" + this.steps + "次, 搜索到" + key); } } private Node searchNode(Node from, int key) { this.steps++; if(from == null || key == from.data) { return from; } else if(key > from.data) { return searchNode(from.rightChild, key); } else { return searchNode(from.leftChild, key); } }
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。
二叉搜索数完整代码如下:
public class BinarySearchTree { private Node root; private int steps; /** * 插入节点 * @param key */ public void add(int key) { if(root == null) { root = new Node(key); return; } addNode(root, new Node(key)); } private void addNode(Node parent, Node child) { if(child.data == parent.data) { return; } if(child.data < parent.data) { if(parent.leftChild != null) { addNode(parent.leftChild, child); } else { parent.leftChild = child; } } else { if(parent.rightChild != null) { addNode(parent.rightChild, child); } else { parent.rightChild = child; } } } /** * 查找节点 * @param key */ public void search(int key) { this.steps = 0; Node node = searchNode(root, key); if(node == null) { System.out.println("共查找" + this.steps + "次, 未找到" + key); } else { System.out.println("共查找" + this.steps + "次, 搜索到" + key); } } private Node searchNode(Node from, int key) { this.steps++; if(from == null || key == from.data) { return from; } else if(key > from.data) { return searchNode(from.rightChild, key); } else { return searchNode(from.leftChild, key); } } /** * 删除节点 * @param key */ public void delete(int key) { Node child = root; Node parent = child; boolean isLeftChild = true; while(child != null) { if(child.data == key) { deleteNode(parent, child, isLeftChild); child = null; } else if(key < child.data) { isLeftChild = true; parent = child; child = child.leftChild; } else { isLeftChild = false; parent = child; child = child.rightChild; } } } private void deleteNode(Node parent, Node child, boolean isLeftChild) { if(child.leftChild == null && child.rightChild == null) { if(isLeftChild) { parent.leftChild = null; } else { parent.rightChild = null; } } else if(child.leftChild == null) { if(isLeftChild) { parent.leftChild = child.rightChild; } else { parent.rightChild = child.rightChild; } } else if(child.rightChild == null) { if(isLeftChild) { parent.leftChild = child.leftChild; } else { parent.rightChild = child.leftChild; } } else { Node leaf = child.rightChild; parent = child; while(leaf.leftChild != null) { parent = leaf; leaf = leaf.leftChild; } child.data = leaf.data; if(parent != child) parent.leftChild = leaf.leftChild; else parent.rightChild = leaf.rightChild; } } /** * 中序遍历二叉搜索树, 结果是从小到大排列的 * @param node */ public void inOrder(Node node) { if(node == null) { return; } inOrder(node.leftChild); System.out.print(node.data + " "); inOrder(node.rightChild); } private static class Node { Node leftChild; Node rightChild; int data; public Node(int data) { this.data = data; } } public static void main(String[] args) { int[] datas = new int[] { 8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15 }; BinarySearchTree bsTree = new BinarySearchTree(); for(int i = 0; i < datas.length; i++) { bsTree.add(datas[i]); } System.out.print("中序遍历"); bsTree.inOrder(bsTree.root); System.out.println(); bsTree.search(8); bsTree.search(12); bsTree.search(15); System.out.println("删除节点8"); bsTree.delete(8); System.out.print("中序遍历"); bsTree.inOrder(bsTree.root); System.out.println(); bsTree.search(8); } }
运行结果:
中序遍历1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 共查找1次, 搜索到8 共查找2次, 搜索到12 共查找4次, 搜索到15 删除节点8 中序遍历1 2 3 4 5 6 7 9 10 11 12 13 14 15 共查找5次, 未找到8本例中的二叉树结构是一种理想情况,如果对数组{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}使用上面的方法构建二叉搜索树,动手画一下就可以发现最终得到的仍然是一个链表,查找15需要比较15次。
这棵树根的左右严重失衡,左侧一个子节点都没有,而右侧的深度为15。为了保证查找的效率,需要对这棵树做优化,让整棵树保持一定的平衡,这就是下一篇的主角:平衡二叉搜索树。
相关文章推荐
- 用java写 java1,1,2,4,7,13,24,44算法
- 常见算法-将二叉搜索树转化为排序的双向链表(java版)
- java经典算法_018有一分数序列:2/1,3/2,5/3,8/5,13/8,21/13...求出这个数列的前20项之和。
- 【算法与数据结构】二叉搜索树的Java实现
- 笔试面试算法经典--二叉搜索树转有序的双向链表(Java)
- 二叉搜索树算法详解与Java实现
- Java与算法(13)
- Java数据结构与算法(31) - ch13图(拓扑)
- 二叉搜索树算法详解与Java实现
- 【算法-java】判断该数组是不是某二叉搜索树的后序遍历的结果
- 【LeetCode-面试算法经典-Java实现】【096-Unique Binary Search Trees(唯一二叉搜索树)】
- 【LeetCode-面试算法经典-Java实现】【096-Unique Binary Search Trees(唯一二叉搜索树)】
- java每日小算法(13)
- 【LeetCode-面试算法经典-Java实现】【098-Validate Binary Search Tree(验证二叉搜索树)】
- 13-02 Java 数组高级算法,Arrays类
- 利用高级Java、算法、三角学、分布计算设计自己的智能机器人--(重锤痛击续2)
- 18位身份证号码校验码的算法(JAVA)
- 在java中实现图形学中的直线算法
- 在java语言计算数据库记录总数的简便算法
- java实现的18位身份证格式验证算法