Java 大话数据结构(11) 查找算法(二叉排序树/二叉搜索树)
Posted 华仔要长胖
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java 大话数据结构(11) 查找算法(二叉排序树/二叉搜索树)相关的知识,希望对你有一定的参考价值。
本文根据《大话数据结构》一书,实现了Java版的二叉排序树/二叉搜索树。
二叉排序树介绍
在上篇博客中,顺序表的插入和删除效率还可以,但查找效率很低;而有序线性表中,可以使用折半、插值、斐波那契等查找方法来实现,但因为要保持有序,其插入和删除操作很耗费时间。
二叉排序树(Binary Sort Tree),又称为二叉搜索树,则可以在高效率的查找下,同时保持插入和删除操作也又较高的效率。下图为典型的二叉排序树。
二叉查找树具有以下性质:
(1) 若任意节点的左子树不空,则左子树上所有结点的值均小于它的根结点的值;
(2) 任意节点的右子树不空,则右子树上所有结点的值均大于它的根结点的值;
(3) 任意节点的左、右子树也分别为二叉查找树。
查找操作
思路:查找值与结点数据对比,根据大小确定往左子树还是右子树进行下一步比较。
采用递归的查找算法
/* * 查找 */ public boolean SearchBST(int key) { return SearchBST(key, root); } private boolean SearchBST(int key, Node node) { if (node == null) return false; if (node.data == key) { return true; } else if (node.data < key) { return SearchBST(key, node.rChild); } else { return SearchBST(key, node.lChild); } }
采用非递归的查找算法
/* * 查找,非递归 */ public boolean SearchBST2(int key) { Node p = root; while (p != null) { if (p.data > key) { p = p.lChild; } else if (p.data < key) { p = p.rChild; } else { return true; } } return false; }
插入操作
思路:与查找类似,但需要一个父节点来进行赋值。
采用非递归的插入算法:
/* * 插入,自己想的,非递归 */ public boolean InsertBST(int key) { Node newNode = new Node(key); if (root == null) { root = newNode; return true; } Node f = null; // 指向父结点 Node p = root; // 当前结点的指针 while (p != null) { if (p.data > key) { f = p; p = p.lChild; } else if (p.data < key) { f = p; p = p.rChild; } else { System.out.println("树中已有相同数据,不再插入!"); return false; } } if (f.data > key) { f.lChild = newNode; } else if (f.data < key) { f.rChild = newNode; } return true; }
采用递归的插入算法:
/* * 插入,参考别人博客,递归 * 思路:把null情况排除后用递归,否则无法赋值 */ public boolean InsertBST2(int key) { if (root == null) { root = new Node(key); return true; } return InsertBST2(key, root); } private boolean InsertBST2(int key, Node node) { if (node.data > key) { if (node.lChild == null) { node.lChild = new Node(key); return true; } else { return InsertBST2(key, node.lChild); } } else if (node.data < key) { if (node.rChild == null) { node.rChild = new Node(key); return true; } else { return InsertBST2(key, node.rChild); } } else { System.out.println("树中已有相同数据,不再插入!"); return false; } }
新补充:在写【Java】 大话数据结构(12) 查找算法(3) (平衡二叉树(AVL树))这篇博客时,发现以下的插入方法比较好(如果没有要求返回值必须为boolean格式的话):(推荐使用此类方法)
/* * 插入操作 */ public void insert(int key) { root = insert(root, key); } private Node insert(Node node, int key) { if (node == null) { // System.out.println("插入成功!"); // 也可以定义一个布尔变量来保存插入成功与否 return new Node(key); } if (key == node.data) { System.out.println("数据重复,无法插入!"); } else if (key < node.data) { node.lChild=insert(node.lChild, key); } else { node.rChild=insert(node.rChild, key); } return node; }
删除操作
思路:
(1)删除叶子结点
直接删除;
(2)删除仅有左或右子树的结点
子树移动到删除结点的位置即可;
(3)删除左右子树都有的结点
找到删除结点p的直接前驱(或直接后驱)s,用s来替换结点p,然后删除结点s,如下图所示。
首先找到删除结点位置及其父结点
/* * 删除操作,先找到删除结点位置及其父结点 * 因为需要有父结点,所以暂时没想到递归的方法(除了令Node对象带个parent属性) */ public boolean deleteBST(int key) { if (root == null) { System.out.println("空表,删除失败"); return false; } Node f = null; // 指向父结点 Node p = root; // 指向当前结点 while (p != null) { if (p.data > key) { f = p; p = p.lChild; } else if (p.data < key) { f = p; p = p.rChild; } else { delete(p, f); return true; } } System.out.println("该数据不存在"); return false; }
再根据上述思路进行结点p的删除:(需注意删除结点为根节点的情况)
/* * 删除结点P的操作 * 必须要有父结点,因为Java无法直接取得变量p的地址(无法使用*p=(*p)->lChild) */ private void delete(Node p, Node f) {// p为删除结点,f为其父结点 if (p.lChild == null) { // 左子树为空,重接右子树 if (p == root) { // 被删除结点为根结点时,无法利用f,该情况不能忽略 root = root.rChild; p = null; } else { if (f.data > p.data) { // 被删结点为父结点的左结点,下同 f.lChild = p.rChild; p = null; // 释放结点别忘了 } else {// 被删结点为父结点的右结点,下同 f.rChild = p.rChild; p = null; } } } else if (p.rChild == null) { // 右子树为空,重接左子树 if (p == root) { // 被删除结点为根结点 root = root.lChild; p = null; } else { if (f.data > p.data) { f.lChild = p.lChild; p = null; } else { f.rChild = p.lChild; p = null; } } } else { // 左右子树都不为空,删除位置用前驱结点替代 Node q, s; q = p; s = p.lChild; while (s.rChild != null) { // 找到待删结点的最大前驱s q = s; s = s.rChild; } p.data = s.data; // 改变p的data就OK if (q != p) { q.rChild = s.lChild; } else { q.lChild = s.lChild; } s = null; } }
完整代码(含测试代码)
package BST; /** * 二叉排序树(二叉查找树) * 若是泛型,则要求满足T extends Comparable<T> static问题 * @author Yongh * */ class Node { int data; Node lChild, rChild; public Node(int data) { this.data = data; lChild = null; rChild = null; } } public class BSTree { private Node root; public BSTree() { root = null; } /* * 查找 */ public boolean SearchBST(int key) { return SearchBST(key, root); } private boolean SearchBST(int key, Node node) { if (node == null) return false; if (node.data == key) { return true; } else if (node.data < key) { return SearchBST(key, node.rChild); } else { return SearchBST(key, node.lChild); } } /* * 查找,非递归 */ public boolean SearchBST2(int key) { Node p = root; while (p != null) { if (p.data > key) { p = p.lChild; } else if (p.data < key) { p = p.rChild; } else { return true; } } return false; } /* * 插入,自己想的,非递归 */ public boolean InsertBST(int key) { Node newNode = new Node(key); if (root == null) { root = newNode; return true; } Node f = null; // 指向父结点 Node p = root; // 当前结点的指针 while (p != null) { if (p.data > key) { f = p; p = p.lChild; } else if (p.data < key) { f = p; p = p.rChild; } else { System.out.println("数据重复,无法插入!"); return false; } } if (f.data > key) { f.lChild = newNode; } else if (f.data < key) { f.rChild = newNode; } return true; } /* * 插入,参考别人博客,递归 * 思路:类似查找, * 但若方法中的node为null的话,将无法插入新数据,需排除null的情况 */ public boolean InsertBST2(int key) { if (root == null) { root = new Node(key); return true; } return InsertBST2(key, root); } private boolean InsertBST2(int key, Node node) { if (node.data > key) { if (node.lChild == null) { // 有null的情况下,才有父结点 node.lChild = new Node(key); return true; } else { return InsertBST2(key, node.lChild); } } else if (node.data < key) { if (node.rChild == null) { node.rChild = new Node(key); return true; } else { return InsertBST2(key, node.rChild); } } else { System.out.println("数据重复,无法插入!"); return false; } } /* * 这样的插入是错误的(node无法真正被赋值) */ /* private boolean InsertBST2(int key, Node node) { if(node!=null) { if (node.data > key) return InsertBST2(key, node.lChild); else if (node.data < key) return InsertBST2(key, node.rChild); else return false;//重复 }else { node=new Node(key); return true; } } */ /* * 删除操作,先找到删除结点位置及其父结点 * 因为需要有父结点,所以暂时没想到递归的方法(除了令Node对象带个parent属性) */ public boolean deleteBST(int key) { if (root == null) { System.out.println("空表,删除失败"); return false; } Node f = null; // 指向父结点 Node p = root; // 指向当前结点 while (p != null) { if (p.data > key) { f = p; p = p.lChild; } else if (p.data < key) { f = p; p = p.rChild; } else { delete(p, f); System.out.println("删除成功!"); return true; } } System.out.println("该数据不存在"); return false; } /* * 删除结点P的操作 * 必须要有父结点,因为Java无法直接取得变量p的地址(无法使用*p=(*p)->lChild) */ private void delete(Node p, Node f) {// p为删除结点,f为其父结点 if (p.lChild == null) { // 左子树为空,重接右子树 if (p == root) { // 被删除结点为根结点,该情况不能忽略 root = root.rChild; p = null; } else { if (f.data > p.data) { // 被删结点为父结点的左结点,下同 f.lChild = p.rChild; p = null; // 释放结点别忘了 } else {// 被删结点为父结点的右结点,下同 f.rChild = p.rChild; p = null; } } } else if (p.rChild == null) { // 右子树为空,重接左子树 if (p == root) { // 被删除结点为根结点 root = root.lChild; p = null; } else { if (f.data > p.data) { f.lChild = p.lChild; p = null; } else { f.rChild = p.lChild; p = null; } } } else { // 左右子树都不为空,删除位置用前驱结点替代 Node q, s; q = p; s = p.lChild; while (s.rChild != null) { // 找到待删结点的最大前驱s q = s; s = s.rChild; } p.data = s.data; // 改变p的data就OK if (q != p) { q.rChild = s.lChild; } else { q.lChild = s.lChild; } s = null; } } /* * 中序遍历 */ public void inOrder() { inOrder(root); System.out.println(); } public void inOrder(Node node) { if (node == null) return; inOrder(node.lChild); System.out.print(node.data + " "); inOrder(node.rChild); } /* * 测试代码 */ public static void main(String[] args) { BSTree aTree = new BSTree(); BSTree bTree = new BSTree(); int[] arr = { 62, 88, 58, 47, 35, 73, 51, 99, 37, 93 }; for (int a : arr) { aTree.InsertBST(a); bTree.InsertBST2(a); } aTree.inOrder(); bTree.inOrder(); System.out.println(aTree.SearchBST(35)); System.out.println(bTree.SearchBST2(99)); aTree.deleteBST(47); aTree.inOrder(); } }
35 37 47 51 58 62 73 88 93 99 35 37 47 51 58 62 73 88 93 99 true true 删除成功! 35 37 51 58 62 73 88 93 99
小结(自己编写时的注意点):
查找:操作简单,注意递归的方法没有循环while (p!=null),而是并列的几个判断;
插入:非递归时,要有父结点;递归时,要注意排除null的情况;
删除:记住要分两步,第一步找结点位置时也要把父结点带上;第二步删除结点时,要令p=null,还要注意p==root的情况以及q==p的情况。
以上是关于Java 大话数据结构(11) 查找算法(二叉排序树/二叉搜索树)的主要内容,如果未能解决你的问题,请参考以下文章