数据结构--二叉树

一 。二叉树的性质

二 。二叉树的实现

 

public class Node {
	public int data;
	public String sData;
	public Node leftChild;
	public Node rightChild;
	
	public Node(int data,String sData){
		this.data=data;
		this.sData=sData;
	}
}

public class BinaryTree {
	//根节点
	public Node root;
	
	
	/**
	 * 插入节点
	 * @param val
	 */
	public void insert(int val,String s){
		Node newNode=new Node(val,s);
		Node cur=root;
		//引用父节点
		Node parent;
		if(root==null){
			root=newNode;
			return;
		}else{
			while(true){
				parent=cur;
				//当前节点比插入的数要大
				if(cur.data>val){
					cur=cur.leftChild;
					if(cur==null){
						parent.leftChild=newNode;
						return;
					}
				}else{
					cur=cur.rightChild;
					if(cur==null){
						parent.rightChild=newNode;
						return;
					}
				}
			}
		}
	}
	
	/**
	 * 
	 * 查找节点
	 */
	public Node find(int val){
		Node cur=root;
		//循环，只要查找值不等于当前节点的数据项
		while(cur.data != val){
			if(cur.data>val){
				cur=cur.leftChild;
			}else{
				cur=cur.rightChild;
			}
			if(cur==null){
				return null;
			}
		}
		return cur;
	}
	
	/**
	 * 删除节点
	 * 
	 * 二叉树的删除是比较复杂的操作
	 *     被删除的节点是叶子节点               	度=0
	 *     被删除的节点只有 左孩子节点      	度=1
	 *     被删除的节点只有 右孩子节点	   	 度=1
	 *     被删除的节点  有两个孩子节点    	度=2
	 */
	public boolean delete(int val){
		Node cur=root;
		Node parent=root;
		boolean isLeftChild=true;
		while(cur.data !=val){
			if(cur.data > val){
				parent=cur;
				cur=cur.leftChild;
				isLeftChild=true;
			}else{
				cur=cur.rightChild;
				isLeftChild=false;
			}
			if(cur==null) return false;
		}
		
		//删除叶子节点  没有子节点 度=0
		if(cur.leftChild==null && cur.rightChild==null){
			if(cur==root){
				root=null;
			}else if(isLeftChild){
				parent.leftChild=null;
			}else{
				parent.rightChild=null;
			}
		
		//被删除的节点只有 左孩子节点
		if(cur.rightChild==null)
			if(cur==root){
				root=cur.leftChild;
				
			}else if(isLeftChild){
				parent.leftChild=cur.leftChild;
				
			}else{
				parent.rightChild=cur.leftChild;
				
			}
		}
		
		//被删除的节点只有 右孩子节点  左子节点不存在
		if(cur.leftChild==null){
			if(cur==root){
				root=cur.rightChild;
			}else if(isLeftChild){
				parent.leftChild=cur.rightChild;
			}else{
				parent.rightChild=cur.rightChild;
			}
		}
		
		// 被删除的节点  有两个孩子节点
		if(cur.leftChild !=null && cur.rightChild !=null){
			Node success=getSuccess(cur);
			if(cur==root){
				root=success;
			}else if(isLeftChild){
				parent.leftChild=success;
			}else{
				parent.rightChild=success;
			}
			success.leftChild=cur.leftChild;
		}
		return true;
	}
	
	public Node getSuccess(Node delNode){
		Node suc=delNode;
		Node sucParent=delNode;
		Node cur=delNode.rightChild;
		
		while(cur != null){
			sucParent=suc;
			suc=cur;
			cur=cur.leftChild;
		}
		if(suc !=delNode.rightChild){
			sucParent.leftChild=suc.rightChild;
			suc.rightChild=delNode.rightChild;
		}
		return suc;
	}
	
	
	
	
	/**
	 * 前序遍历  根左右
	 */
	public void preOrder(Node node){
		if(node != null){
			System.out.print(node.data+","+node.sData+" ");
			preOrder(node.leftChild);
			preOrder(node.rightChild);
		}
	}
	
	/**
	 * 中序遍历  左根右
	 */
	public void inOrder(Node node){
		if(node !=null){
			inOrder(node.leftChild);
			System.out.print(node.data+","+node.sData+" ");
			inOrder(node.rightChild);
		}
	}
	
	/**
	 * 后序遍历  左右根
	 */
	public void afterOrder(Node localNode) {
		if(localNode != null) {
			//后序遍历左子树
			afterOrder(localNode.leftChild);
			//后序遍历右子树
			afterOrder(localNode.rightChild);
			//访问根节点
			System.out.print(localNode.data+","+localNode.sData+" ");
		}
	}
}

public class TestTree {
	public static void main(String[] args) {
		BinaryTree tree=new BinaryTree();
		
		tree.insert(10, "jane");
		tree.insert(20, "can");
		tree.insert(5, "youku");
		tree.insert(15, "do");
		tree.insert(30, "macop");
		tree.insert(40, "maciop");
		
		System.out.println(tree.root.data);
		System.out.println(tree.root.rightChild.data);
		System.out.println(tree.root.leftChild.data);
		System.out.println(tree.root.rightChild.leftChild.data);
		
		Node node=tree.find(5);
		System.out.println(node.data+","+node.sData);
		
		
		//遍历
		tree.afterOrder(tree.root);
		System.out.println();
		
		tree.delete(15);
		tree.afterOrder(tree.root);
	}
}