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 
BSTree

 

 小结(自己编写时的注意点):

  查找:操作简单,注意递归的方法没有循环while (p!=null),而是并列的几个判断;

  插入:非递归时,要有父结点;递归时,要注意排除null的情况;

  删除:记住要分两步,第一步找结点位置时也要把父结点带上;第二步删除结点时,要令p=null,还要注意p==root的情况以及q==p的情况。

 

以上是关于Java 大话数据结构(11) 查找算法(二叉排序树/二叉搜索树)的主要内容,如果未能解决你的问题,请参考以下文章

大话数据结构C语言56 二叉排序树的查找插入和删除

大话数据结构之查找

大话数据结构之查找

大话数据结构C语言55 二叉排序树

Python 常用查找数据结构及算法

大话数据结构C语言69 归并排序(递归和迭代实现)