二叉查找树（java）

实现二叉查找树的查找、插入、最大值、最小值、删除

/**
 * 二叉查找树：
 * 1.若任意节点的左子树不为空，则左子树的所有的节点值均小于根节点的值；
 * 2.若任意节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值；
 * 3.任意节点的左右子树也分别为二叉查找树；
 * 4.！！！！ 没有键值相等的节点；
 */

public class Binary_Search_Tree {
	
	//查找，插入、删除，最大值、最小值、删除
	
	/**
	 * 查找二叉树root中键值为key的节点
	 * 1.root == null，返回null
	 * 2.root不为null,比较root的键值和key
	 * 3.root.key > key; 在左子树中查找 --- 递归
	 * 4.root.key < key ,在右子树中查找 --- 递归
	 * 
	 */
	public static BsNode search(BsNode root, int key) {
		if (root != null) {
			if (key < root.key) {
				return search(root.left, key); // 递归查找左子树
			}else if (key > root.key) {
				return search(root.right, key);
			}else {
				return root;
			}
			
		}
		return null;
	}
	
	/**
	 * 查找二叉查找树root的最大值
	 * 1. root为null，返回null
	 * 2. root不为null:
	 * 2.1 root.right为null，返回root
	 * 2.2 root.right不为null，递归查询root的右子树
	 */
	public static BsNode searchMaxKey(BsNode root) {
		if (root != null) {
			if (root.right == null) {
				return root;
			}else {
				return searchMaxKey(root.right);
			}
		}
		
		return null;
	}
	
	/**
	 * 查找二叉查找树root的最小值
	 * 1. root为null,返回null;
	 * 2.root 不为null;
	 * 2.1 root的左子树为空，返回root
	 * 2.2 root的左子树不为空,递归查询root的左子树
	 */
	public static BsNode searchMin(BsNode root) {
		if (root != null) {
			if (root.left == null) {
				return root;
			}else {
				return searchMin(root.left);
			}
		}
		return null;
	}
	
	/**
	 * 插入节点 
	 * 1. 如果二叉查找树为空，根节点的key为data
	 * 2.二叉查找树不为空:
	 * 2.1 比较data与root的键值
	 * 2.2 若大于，则判断右子树是否为空，如为空，插入，不为空，继续执行2.1 -- 递归
	 * 2.2 若小于，判断左子树是否为空，为空，插入，不为空，继续执行2.1 -- 递归
	 * 2.3若相等，return；
	 */
	public static void insert(BsNode root, int data) {
		if (root == null) {
			root = new BsNode(data);
		}
		
		if (data < root.key) {
			if (root.left == null) {
				root.left = new BsNode(data);
			}else {
				insert(root.left, data);
			}
		}else if (data > root.key) {
			if (root.right  == null) {
				root.right = new BsNode(data);
			}else {
				insert(root.right, data);
			}
		}else {
			return;
		}
		
	}
	
	/**
	 * 删除
	 * 1. 被删除节点没有子节点，即为叶子节点：直接删除，父节点对应的子节点置空
	 * 2. 被删除节点的左子树或者右子树为空，删除该节点，让其父节点关联其子节点；
	 * 3. 左右子树都不为空：把该节点的直接前驱（该节点左子树中的最大节点）或者直接后继节点（该节点右子树中的最小节点）替换该节点，删除直接前驱节点或者直接后继节点
	 * @return 返回根节点
	 */
	public static BsNode delete(BsNode root, int data) {
		if (root == null) {
			return null;
		}
		BsNode node = search(root, data);
		return deletePro(root, node);
		
	}
	public static BsNode deletePro(BsNode root,BsNode node) {
		//情况一：
		if (node.left == null && node.right == null) {
			if (node == root) {//被删除节点为根节点
				root = null;
			}else {
				if (node.parent.left == node) {
					node.parent.left = null;
				}else {
					node.parent.right = null;
				}
			}
			
		}else if (node.left == null) { //情况二
			if (node == root) { //被删除节点为根节点
				root = root.right;
				root.parent = null;
			}else {
				if (node.parent.left == node) { //该节点是其父节点的左节点
					node.parent.left = node.right;
				}else {							//该节点是其父节点的右节点
					node.parent.right = node.right;
				}
				node.right.parent = node.parent;
			}
			
		}else if (node.right == null) { //情况二
			if (node == root) { //被删除节点为根节点
				root = root.left;
				root.parent = null;
			}else {
				if (node.parent.left == node) {
					node.parent.left = node.left;
				}else {
					node.parent.right = node.left;
				}
				node.left.parent = node.parent;
			}
			
		}else { //情况三
			BsNode preNode =null;
			if (node == root) {
				preNode = searchMaxKey(root.left);// 获取前驱节点
				
				root.key = preNode.key;
				
			}else {
				preNode = searchMaxKey(node.left);// 获取前驱节点
				node.key = preNode.key;
			}
			//删除前驱节点
			deletePro(root, preNode);
			
		}
		return root;
	}
	
	/**
	 * 层次遍历
	 * 
	 */
	public static void LevelTree(BsNode root) {
		if (root == null) {
			return;
		}
		Queue<BsNode> queue = new ArrayDeque<BsNode>();
		queue.add(root);
		while(!queue.isEmpty()) {
			BsNode node = queue.poll();//获取队首元素，并从队列中删除
			System.out.println(node.key);
			if (node.left != null) {
				queue.add(node.left); //左节点入队
			}
			if (node.right != null) {
				queue.add(node.right); //右节点入队
			}
			
		}
	}
	//测试
	public static void main(String[] args) {
		//创建一颗二叉树 9（5（2,7），13（12（10），14））
		/*BsNode root = new BsNode(9);
		BsNode node1 = new BsNode(5);BsNode node2 = new BsNode(13);
		root.left = node1; root.right = node2;
		
		BsNode node1_1 = new BsNode(2); BsNode node1_2 = new BsNode(7);
		node1.left = node1_1; node1.right = node1_2;
		
		BsNode node2_1 = new BsNode(12); BsNode node2_2 = new BsNode(14);
		node2.left=node2_1; node2.right=node2_2;
		
		BsNode node2_1_1 = new BsNode(10);
		node2_1.left = node2_1_1; 
		
		
		int key = 12;
		BsNode bsNode = search(root,key);
		System.out.println("key为"+key+"节点存在否：   "+ ((bsNode !=null)?"存在":"不存在"));
		
		System.out.println("二叉树的最大key值："+searchMaxKey(root).key);
		
		System.out.println("二叉树的最小key值："+searchMin(root).key);
		
		insert(root, 11);
		System.out.println("插入节点后的中序遍历");
		LDR(root);*/
		
		//叶子节点
		BsNode node1 = new BsNode(6, null, null); BsNode node2 = new BsNode(8, null, null);
		BsNode node3 = new BsNode(10, null, null); BsNode node4 = new BsNode(14, null, null);
		BsNode node5 = new BsNode(7, node1, node2);
		BsNode node6 = new BsNode(12, node3, null);
		BsNode node7 = new BsNode(13, node6, node4);
		BsNode node8 = new BsNode(5, null, node5);
		BsNode root = new BsNode(9, node8, node7);
		node1.parent = node5; node2.parent = node5;
		node3.parent = node6; node4.parent = node7;
		node5.parent = node8; node6.parent = node7;
		node7.parent = root; node8.parent = root;
		
		//LevelTree(root);
		
		delete(root, 9);
		//delete(root, 13);
		//delete(root, 8);
		//delete(root, 12);
		//delete(root, 5);
		System.out.println("删除节点后");
		//LDR(root);
		LevelTree(root);
	}

}

class BsNode{
	//三叉节点
	
	int key;
	
	BsNode left;
	
	BsNode right;
	
	BsNode parent;

	public BsNode(int key, BsNode left, BsNode right, BsNode parent) {
		super();
		this.key = key;
		this.left = left;
		this.right = right;
		this.parent = parent;
	}
	public BsNode(int key, BsNode left, BsNode right) {
		super();
		this.key = key;
		this.left = left;
		this.right = right;
	}
	
	public BsNode(int key) {
		super();
		this.key = key;
	}
	
}