数据结构(4)：二叉树

二叉树知识点

代码实现：

package binaryTree;
public class BinaryTree	{
	public BinaryNode root;//根节点
	
	public BinaryTree(){
		root = null;
	}	
	
	//查找某个特定值的节点
	public BinaryNode findNode(int data){
		//临时节点用于查找
		BinaryNode current = root;
		if(root == null){
			return null;	
		}
		while(data != current.data){
			if(data < current.data){
				current = current.leftChild;
			}else{
				current = current.rightChild;
			}
			if(current == null){
				System.out.println("没有值为" + data + "的节点");
				return null;	
			}
		}
		return current;
	}

	//插入节点
	public void insert(int data){
		//创建新节点
		BinaryNode newNode = new BinaryNode(data);
		//创建要插入节点的父节点以及要插入节点的位置
		BinaryNode current = root;
		BinaryNode parent;
		if(root == null){
			root = newNode;
		}else{
			while(true){
				parent = current;
				if(data < current.data){
					current = current.leftChild;
					if(current == null){
						parent.leftChild = newNode;
						newNode.parent = parent;
						return;
					}
				}else{
					current = current.rightChild;
					if(current == null){
						parent.rightChild = newNode;
						newNode.parent = parent;
						return;
					}
				}
			}
		}
	}
	
	//递归实现遍历二叉树
	public void traverse(int sort){
		switch(sort){
			case 1:System.out.println("前序遍历");
				preTraverse(root);
				break;
			case 2:System.out.println("中序遍历");
				minTraverse(root);
				break;
			case 3:System.out.println("后序遍历");
				backTraverse(root);
				break;
			default:System.out.println("前序遍历");
				preTraverse(root);
				break;
			
		}
	}
	
	//前序遍历
	public void preTraverse(BinaryNode binaryNode){
		if(binaryNode != null){
			System.out.println(binaryNode.data);
			preTraverse(binaryNode.leftChild);
			preTraverse(binaryNode.rightChild);
		}
	}
	
	//中序遍历
	public void minTraverse(BinaryNode binaryNode){
		if(binaryNode){
			minTraverse(binaryNode.leftChild);
			System.out.println(binaryNode.data);
			minTraverse(binaryNode.rightChild);			
		}
	}
	
	//后序遍历
	public void backTraverse(BinaryNode binaryNode){
		if(binaryNode != null){
			backTraverse(binaryNode.leftChild);
			backTraverse(binaryNode.rightChild);
			System.out.println(binaryNode.data);
		}
	}
	
	//查找最小的元素(即树最'左'的节点)
	public BinaryNode findMin(){
		BinaryNode parent = root;
		BinaryNode current = root;
		if(root == null){
			return null;
		}else{
			while(current != null){
				parent = current;
				current = current.leftChild;
			}
		}
		return parent;
	}
	
	//查找最大的元素(即树最'右'的节点)
	public BinaryNode findMax(){
		BinaryNode parent = root;
		BinaryNode current = root;
		if(root == null){
			return null;
		}else{
			while(current != null){
				parent = current;
				current = current.rightChild;
			}
		}
		return parent;
	}
	
	/*
	*	删除节点，要分三种情况
	*	要删除的节点没有子节点
	*	要删除的节点只有一个子节点
	*	要删除的节点有两个子节点
	*/
	public boolean delete(int data){
		//创建临时节点用于找到要删除的节点
		BinaryNode current = root;
		//判断该节点是左节点还是右节点
		boolean isLeftChild =true;
		while(current.data != data){
			if(data < current.data){
				current = current.leftChild;
			}else{
				current = current.rightChild;
			}
			if(current == null){
				System.out.println("没有值为" + data + "的节点");
				return false;
			}
		}
		//找到了要被删除的节点
		if(current.leftChild == null && current.rightChild ==null){
			//要删除的节点没有子节点
			return deleteNoChild(current,isLeftChild);
		}else if(current.leftChild != null && current.rightChild != null){
			//要删除的节点有两个子节点
			return deleteTwoChild(current,isLeftChild);
		}else{
			//要删除的节点只有一个子节点
			return deleteOneChild(current,isLeftChild);
		}
	}

	//要删除的节点没有子节点
	public boolean deleteNoChild(BinaryNode delNode,boolean isLeftChild){
		if(delNode == root){
			//要删除的节点是根节点
			root = null;
			return true;
		}else{
			if(isLeftChild){
				//要删除的节点是左节点
				delNode.parent.leftChild = null;
				return true;
			}else{
				//要删除的节点是右节点
				delNode.parent.rightChild = null;
				return true;
			}
		}
	}

	//要删除的节点有一个子节点
	public boolean deleteOneChild(BinaryNode delNode,boolean isLeftChild){
		if(delNode.leftChild == null){
			//要删除的节点只有右子节点
			//要删除的节点为根节点
			if(delNode == root){
				root = delNode.rightChild;
				delNode.rightChild.parent = null; 
				return true;
			}
			if(isLeftChild){
				//要删除的节点是左子结点
				delNode.parent.leftChild = delNode.rightChild;
			}else{
				//要删除的节点是右子节点
				delNode.parent.rightChild = delNode.rightChild;
			}
			delNode.rightChild.parent = delNode.parent;
			return true;
		}else{
			//要删除的节点只有左子结点
			//要删除的节点为根节点
			if(delNode == root){
				root = delNode.leftChild;
				delNode.leftChild.parent = null;
			}
			if(isLeftChild){
				//要删除的节点是左子结点
				delNode.parent.leftChild = delNode.leftChild;
			}else{
				//要删除的节点是右子节点
				delNode.parent.rightChild = delNode.leftChild;
			}
			delNode.leftChild.parent = delNode.parent;
			return true;
		}
	}
	
	//要删除的节点有两个子节点
	public boolean deleteTwoChild(BinaryNode delNode,boolean isLeftChild){
		//得到要删除节点的后继节点
		BinaryNode successor = getSuccessor(delNode);
		//要删除的节点是根节点
		if(delNode == root){
			delNode.leftChild.parent = successor;//将后继节点与被删除的节点的左边连起来
			successor.leftChild = delNode.leftChild;
			root = successor;
			return true;
		}else{
			//要删除的节点是左子结点
			if(isLeftChild){
				delNode.leftChild.parent = successor;//将后继节点与被删除的节点的左边连起来
				successor.leftChild = delNode.leftChild;
				delNode.leftChild = successor;//将后继节点与被删除的节点的父节点连起来
				successor.parent = delNode.parent;
				return true;
			}else{
				//要删除的节点是右子节点
				//将后继节点与被删除的节点的左边连起来
				delNode.leftChild.parent = successor;
				successor.leftChild = delNode.leftChild;
				delNode.rightChild = successor;//将后继节点与被删除的节点的父节点连起来
				successor.parent = delNode.parent;
				return true;
			}
		}
	}
	
	//获取要删除节点的后继节点
	public BinaryNode getSuccessor(BinaryNode delNode){
		BinaryNode successor = delNode;
		BinaryNode current = delNode.rightChild;
		while(current != null){
			successor = current;
			current = current.leftChild;
		} 
		//找到了后继节点，进一步判断
		if(successor != delNode.rightChild){
			//当后继节点不是要删除节点的右子节点时
			successor.parent.leftChild = successor.rightChild;
			if(successor.rightChild != null){
				successor.rightChild.parent = successor.parent;
			}
			//将后继节点与要删除节点的右边连起来
			delNode.rightChild.parent = successor;
			successor.rightChild = delNode.rightChild;
		}
		return successor;
	}
}

//定义节点类
class BinaryNode {
	public int data;
	public BinaryNode parent;//父节点
	public BinaryNode leftChild;//左子结点
	public BinaryNode rightChild;//右子节点
	public BinaryNode(int data){
		this.data = data;
	}
}

后续如有更优的方法，会继续补充。