java實現二叉樹查找樹

 

二叉樹(binary)是一種特殊的樹。二叉樹的每一個節點最多隻能有2個子節點：

二叉樹

因爲二叉樹的子節點數目肯定，因此能夠直接採用上圖方式在內存中實現。每一個節點有一個左子節點(left children)和右子節點(right children)。左子節點是左子樹的根節點，右子節點是右子樹的根節點。

 

若是咱們給二叉樹加一個額外的條件，就能夠獲得一種被稱做二叉搜索樹(binary search tree)的特殊二叉樹。二叉搜索樹要求：每一個節點都不比它左子樹的任意元素小，並且不比它的右子樹的任意元素大。

(若是咱們假設樹中沒有重複的元素，那麼上述要求能夠寫成：每一個節點比它左子樹的任意節點大，並且比它右子樹的任意節點小)

二叉搜索樹，注意樹中元素的大小

二叉搜索樹能夠方便的實現搜索算法。在搜索元素x的時候，咱們能夠將x和根節點比較:

1. 若是x等於根節點，那麼找到x，中止搜索 (終止條件)

2. 若是x小於根節點，那麼搜索左子樹

3. 若是x大於根節點，那麼搜索右子樹

二叉搜索樹所須要進行的操做次數最多與樹的深度相等。n個節點的二叉搜索樹的深度最多爲n，最少爲log(n)。

 

下面是用java實現的二叉搜索樹，並有搜索，插入，刪除，尋找最大最小節點的操做。

刪除節點相對比較複雜。刪除節點後，有時須要進行必定的調整，以恢復二叉搜索樹的性質(每一個節點都不比它左子樹的任意元素小，並且不比它的右子樹的任意元素大)。

• 葉節點能夠直接刪除。
• 刪除非葉節點時，好比下圖中的節點8，咱們能夠刪除左子樹中最大的元素(或者右樹中最大的元素)，用刪除的節點來補充元素8產生的空缺。但該元素可能也不是葉節點，因此它所產生的空缺須要其餘元素補充…… 直到最後刪除一個葉節點。上述過程能夠遞歸實現。

刪除節點

刪除節點後的二叉搜索樹

 

import java.util.ArrayList;
import java.util.List;

public class BinarySearchTree {

	// 樹的根結點
	private TreeNode root = null;

	// 遍歷結點列表
	private List<TreeNode> nodelist = new ArrayList<TreeNode>();

	private class TreeNode {

		private int key;
		private TreeNode leftChild;
		private TreeNode rightChild;
		private TreeNode parent;

		public TreeNode(int key, TreeNode leftChild, TreeNode rightChild,
				TreeNode parent) {
			this.key = key;
			this.leftChild = leftChild;
			this.rightChild = rightChild;
			this.parent = parent;
		}

		public int getKey() {
			return key;
		}

		public String toString() {
			String leftkey = (leftChild == null ? "" : String
					.valueOf(leftChild.key));
			String rightkey = (rightChild == null ? "" : String
					.valueOf(rightChild.key));
			return "(" + leftkey + " , " + key + " , " + rightkey + ")";
		}

	}

	/**
	 * isEmpty: 判斷二叉查找樹是否爲空；若爲空，返回 true ，不然返回 false .
	 * 
	 */
	public boolean isEmpty() {
		if (root == null) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * TreeEmpty: 對於某些二叉查找樹操做(好比刪除關鍵字)來講，若樹爲空，則拋出異常。
	 */
	public void TreeEmpty() throws Exception {
		if (isEmpty()) {
			throw new Exception("樹爲空!");
		}
	}

	/**
	 * search: 在二叉查找樹中查詢給定關鍵字
	 * 
	 * @param key
	 *            給定關鍵字
	 * @return 匹配給定關鍵字的樹結點
	 */
	public TreeNode search(int key) {
		TreeNode pNode = root;
		while (pNode != null && pNode.key != key) {
			if (key < pNode.key) {
				pNode = pNode.leftChild;
			} else {
				pNode = pNode.rightChild;
			}
		}
		return pNode;
	}

	/**
	 * minElemNode: 獲取二叉查找樹中的最小關鍵字結點
	 * 
	 * @return 二叉查找樹的最小關鍵字結點
	 * @throws Exception
	 *             若樹爲空，則拋出異常
	 */
	public TreeNode minElemNode(TreeNode node) throws Exception {
		if (node == null) {
			throw new Exception("樹爲空！");
		}
		TreeNode pNode = node;
		while (pNode.leftChild != null) {
			pNode = pNode.leftChild;
		}
		return pNode;
	}

	/**
	 * maxElemNode: 獲取二叉查找樹中的最大關鍵字結點
	 * 
	 * @return 二叉查找樹的最大關鍵字結點
	 * @throws Exception
	 *             若樹爲空，則拋出異常
	 */
	public TreeNode maxElemNode(TreeNode node) throws Exception {
		if (node == null) {
			throw new Exception("樹爲空！");
		}
		TreeNode pNode = node;
		while (pNode.rightChild != null) {
			pNode = pNode.rightChild;
		}
		return pNode;
	}

	/**
	 * successor: 獲取給定結點在中序遍歷順序下的後繼結點
	 * 
	 * @param node
	 *            給定樹中的結點
	 * @return 若該結點存在中序遍歷順序下的後繼結點，則返回其後繼結點；不然返回 null
	 * @throws Exception
	 */
	public TreeNode successor(TreeNode node) throws Exception {
		if (node == null) {
			return null;
		}

		// 若該結點的右子樹不爲空，則其後繼結點就是右子樹中的最小關鍵字結點
		if (node.rightChild != null) {
			return minElemNode(node.rightChild);
		}
		// 若該結點右子樹爲空
		TreeNode parentNode = node.parent;
		while (parentNode != null && node == parentNode.rightChild) {
			node = parentNode;
			parentNode = parentNode.parent;
		}
		return parentNode;
	}

	/**
	 * precessor: 獲取給定結點在中序遍歷順序下的前趨結點
	 * 
	 * @param node
	 *            給定樹中的結點
	 * @return 若該結點存在中序遍歷順序下的前趨結點，則返回其前趨結點；不然返回 null
	 * @throws Exception
	 */
	public TreeNode precessor(TreeNode node) throws Exception {
		if (node == null) {
			return null;
		}

		// 若該結點的左子樹不爲空，則其前趨結點就是左子樹中的最大關鍵字結點
		if (node.leftChild != null) {
			return maxElemNode(node.leftChild);
		}
		// 若該結點左子樹爲空
		TreeNode parentNode = node.parent;
		while (parentNode != null && node == parentNode.leftChild) {
			node = parentNode;
			parentNode = parentNode.parent;
		}
		return parentNode;
	}

	/**
	 * insert: 將給定關鍵字插入到二叉查找樹中
	 * 
	 * @param key
	 *            給定關鍵字
	 */
	public void insert(int key) {
		TreeNode parentNode = null;
		TreeNode newNode = new TreeNode(key, null, null, null);
		TreeNode pNode = root;
		if (root == null) {
			root = newNode;
			return;
		}
		while (pNode != null) {
			parentNode = pNode;
			if (key < pNode.key) {
				pNode = pNode.leftChild;
			} else if (key > pNode.key) {
				pNode = pNode.rightChild;
			} else {
				// 樹中已存在匹配給定關鍵字的結點，則什麼都不作直接返回
				return;
			}
		}
		if (key < parentNode.key) {
			parentNode.leftChild = newNode;
			newNode.parent = parentNode;
		} else {
			parentNode.rightChild = newNode;
			newNode.parent = parentNode;
		}

	}

	/**
	 * insert: 從二叉查找樹中刪除匹配給定關鍵字相應的樹結點
	 * 
	 * @param key
	 *            給定關鍵字
	 */
	public void delete(int key) throws Exception {
		TreeNode pNode = search(key);
		if (pNode == null) {
			throw new Exception("樹中不存在要刪除的關鍵字!");
		}
		delete(pNode);
	}

	/**
	 * delete: 從二叉查找樹中刪除給定的結點.
	 * 
	 * @param pNode
	 *            要刪除的結點
	 * 
	 *            前置條件： 給定結點在二叉查找樹中已經存在
	 * @throws Exception
	 */
	private void delete(TreeNode pNode) throws Exception {
		if (pNode == null) {
			return;
		}
		if (pNode.leftChild == null && pNode.rightChild == null) { // 該結點既無左孩子結點，也無右孩子結點
			TreeNode parentNode = pNode.parent;
			if (pNode == parentNode.leftChild) {
				parentNode.leftChild = null;
			} else {
				parentNode.rightChild = null;
			}
			return;
		}
		if (pNode.leftChild == null && pNode.rightChild != null) { // 該結點左孩子結點爲空，右孩子結點非空
			TreeNode parentNode = pNode.parent;
			if (pNode == parentNode.leftChild) {
				parentNode.leftChild = pNode.rightChild;
				pNode.rightChild.parent = parentNode;
			} else {
				parentNode.rightChild = pNode.rightChild;
				pNode.rightChild.parent = parentNode;
			}
			return;
		}
		if (pNode.leftChild != null && pNode.rightChild == null) { // 該結點左孩子結點非空，右孩子結點爲空
			TreeNode parentNode = pNode.parent;
			if (pNode == parentNode.leftChild) {
				parentNode.leftChild = pNode.leftChild;
				pNode.rightChild.parent = parentNode;
			} else {
				parentNode.rightChild = pNode.leftChild;
				pNode.rightChild.parent = parentNode;
			}
			return;
		}
		// 該結點左右孩子結點均非空，則刪除該結點的後繼結點，並用該後繼結點取代該結點
		TreeNode successorNode = successor(pNode);
		delete(successorNode);
		pNode.key = successorNode.key;
	}

	/**
	 * inOrderTraverseList: 得到二叉查找樹的中序遍歷結點列表
	 * 
	 * @return 二叉查找樹的中序遍歷結點列表
	 */
	public List<TreeNode> inOrderTraverseList() {
		if (nodelist != null) {
			nodelist.clear();
		}
		inOrderTraverse(root);
		return nodelist;
	}

	/**
	 * inOrderTraverse: 對給定二叉查找樹進行中序遍歷
	 * 
	 * @param root
	 *            給定二叉查找樹的根結點
	 */
	private void inOrderTraverse(TreeNode root) {
		if (root != null) {
			inOrderTraverse(root.leftChild);
			nodelist.add(root);
			inOrderTraverse(root.rightChild);
		}
	}

	/**
	 * toStringOfOrderList: 獲取二叉查找樹中關鍵字的有序列表
	 * 
	 * @return 二叉查找樹中關鍵字的有序列表
	 */
	public String toStringOfOrderList() {
		StringBuilder sbBuilder = new StringBuilder(" [ ");
		for (TreeNode p : inOrderTraverseList()) {
			sbBuilder.append(p.key);
			sbBuilder.append(" ");
		}
		sbBuilder.append("]");
		return sbBuilder.toString();
	}

	/**
	 * 獲取該二叉查找樹的字符串表示
	 */
	public String toString() {
		StringBuilder sbBuilder = new StringBuilder(" [ ");
		for (TreeNode p : inOrderTraverseList()) {
			sbBuilder.append(p);
			sbBuilder.append(" ");
		}
		sbBuilder.append("]");
		return sbBuilder.toString();
	}

	public TreeNode getRoot() {
		return root;
	}

	public static void testNode(BinarySearchTree bst, TreeNode pNode)
			throws Exception {
		System.out.println("本結點: " + pNode);
		System.out.println("前趨結點: " + bst.precessor(pNode));
		System.out.println("後繼結點: " + bst.successor(pNode));
	}

	public static void testTraverse(BinarySearchTree bst) {
		System.out.println("二叉樹遍歷：" + bst);
		System.out.println("二叉查找樹轉換爲有序列表: " + bst.toStringOfOrderList());
	}

	public static void main(String[] args) {
		try {
			BinarySearchTree bst = new BinarySearchTree();
			System.out.println("查找樹是否爲空？ " + (bst.isEmpty() ? "是" : "否"));
			int[] keys = new int[] { 15, 6, 18, 3, 7, 13, 20, 2, 9, 4 };
			for (int key : keys) {
				bst.insert(key);
			}
			System.out.println("查找樹是否爲空？ " + (bst.isEmpty() ? "是" : "否"));
			TreeNode minkeyNode = bst.minElemNode(bst.getRoot());
			System.out.println("最小關鍵字： " + minkeyNode.getKey());
			testNode(bst, minkeyNode);
			TreeNode maxKeyNode = bst.maxElemNode(bst.getRoot());
			System.out.println("最大關鍵字： " + maxKeyNode.getKey());
			testNode(bst, maxKeyNode);
			System.out.println("根結點關鍵字： " + bst.getRoot().getKey());
			testNode(bst, bst.getRoot());
			testTraverse(bst);
			System.out.println("****************************** ");
			testTraverse(bst);
		} catch (Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}

}