数据结构—树

数据结构—树

树

树 由显示结点间关系的边相联而成的结点集合。如下图

树的根与任意其他结点之间的路径是唯一的。

树的高度是树中层的数目，该高度也等于根与叶子间最长路径上的结点数目。

上图是一棵三叉树，因为A有3个孩子，而二叉树的每个结点至多有两个孩子，分别称为左孩子和右孩子。

二叉树

二叉树分为满二叉树、完全二叉树、不满也不完全的二叉树。

满二叉树：每个非叶结点都有两个孩子。

完全二叉树：直到倒数第二层都是满的，并且最后一层上的叶子是从左向右填满的。

二叉树的高度

满二叉树的结点数n与其树的高度h的关系： n = 2h - 1

含有n个结点的完全二叉树或满二叉树的高度是：h= log2(n+1)向上取整

二叉树的遍历

层序遍历是广度优先遍历，而先序、中序、后序是深度优先遍历。

（1） 先序遍历——访问根是在访问根的子树之前

• 访问根
• 访问根的左子树中的所有结点
• 访问根的右子树中的所有结点

（2） 中序遍历——访问根是在访问根的两棵子树之间

• 访问根的左子树中的所有结点
• 访问根
• 访问根的右子树中的所有结点

（3） 后序遍历——访问根是在访问根的两棵子树之后

• 访问根的左子树中的所有结点
• 访问根的右子树中的所有结点
• 访问根

（4） 层序遍历——从根开始，在树的每一层中从左到右访问结点

1、树的接口

（1）所有树公有的接口方法

public interface TreeInterface<T> {

	public T getRootData();
	public int getHeight();
	public int getNumberOfNodes();
	public boolean isEmpty();
	public void clear();
}

（2）树的遍历方法接口

public interface TreeIteratorInterface<T> {
	public Iterator<T> getPreorderIterator();
	public Iterator<T> getPostorderIterator();
	public Iterator<T> getInorderIterator();
	public Iterator<T> getLevelorderIterator();
	public void display_Inorder();
	public void display_Preorder();
	public void display_Postorder();
	public void display_Levelorder();
}

（3）二叉树的接口

public interface BinaryTreeInterface<T> extends TreeInterface<T>,TreeIteratorInterface<T> {
	/**
	 * Task:将已有的二叉树置为一棵新的单节点二叉树
	 * @param rootData
	 */
	public void setTree(T rootData);
	/**
	 * Task:将已有的二叉树置为一棵新的二叉树
	 * @param rootData
	 * @param leftTree
	 * @param rightTree
	 */
	public void setTree(T rootData,BinaryTreeInterface<T> leftTree,BinaryTreeInterface<T> rightTree);
}

2、树的实现

（1）二叉树的结点

二叉树的结点含有数据对象的引用及其左右孩子的引用，这些左右孩子是树中其它结点。

二叉树结点的接口

public interface BinaryNodeInterface<T> {

	public T getData();
	public void setData(T newData);
	public BinaryNodeInterface<T> getLeftChild();
	public BinaryNodeInterface<T> getRightChild();
	public void setLeftChild(BinaryNodeInterface<T> leftChild);
	public void setRightChild(BinaryNodeInterface<T> rightChild);
	public boolean hasLeftChild();
	public boolean hasRightChild();
	public boolean isLeaf();
	public int getNumberOfNodes();
	public int getHight();
	public BinaryNodeInterface<T> copy();
}

二叉树结点的实现

public class BinaryNode<T> implements BinaryNodeInterface<T>,Serializable {
	
	private T data;
	private BinaryNode<T> left;
	private BinaryNode<T> right;
	
	public BinaryNode() {
		this(null);
	}
	
	public BinaryNode(T data) {
		this(data,null,null);
	}

	public BinaryNode(T data,BinaryNode<T> leftChild,BinaryNode<T> rightChild) {
		this.data=data;
		this.left=leftChild;
		this.right=rightChild;
	}
	
	@Override
	public T getData() {
		return data;
	}

	@Override
	public void setData(T newData) {
		this.data=newData;
	}

	@Override
	public BinaryNodeInterface<T> getLeftChild() {
		return left;
	}

	@Override
	public BinaryNodeInterface<T> getRightChild() {
		return right;
	}

	@Override
	public void setLeftChild(BinaryNodeInterface<T> leftChild) {
		this.left=(BinaryNode<T>) leftChild;
	}

	@Override
	public void setRightChild(BinaryNodeInterface<T> rightChild) {
		this.right=(BinaryNode<T>) rightChild;
	}

	@Override
	public boolean hasLeftChild() {
		return left!=null;
	}

	@Override
	public boolean hasRightChild() {
		return right!=null;
	}

	@Override
	public boolean isLeaf() {
		return left==null && right==null;
	}

	@Override
	public int getNumberOfNodes() {
		int leftNumber=0;
		int rightNumber=0;
		if(left!=null)
			leftNumber=left.getNumberOfNodes();
		if(right!=null)
			rightNumber=right.getNumberOfNodes();
		return 1+leftNumber+rightNumber;
	}

	@Override
	public int getHight() {
		return getHight(this);
	}
	

	public int getHight(BinaryNode<T> node){
		int height=0;
		if(node!=null)
			height=1+Math.max(getHight(node.left), getHight(node.right));
		return height;
	}
	
	@Override
	public BinaryNodeInterface<T> copy() {
		BinaryNode<T> newRoot=new BinaryNode<T>(data);
		if(left!=null)
			newRoot.left=(BinaryNode<T>) left.copy();
		if(right!=null)
			newRoot.right=(BinaryNode<T>) right.copy();
		return newRoot;
	}
}

（2）二叉树的实现

public class BinaryTree<T> implements BinaryTreeInterface<T>,Serializable{

	private BinaryNode<T> root;

	public BinaryTree() {
		root=null;
	}

	public BinaryTree(T rootData) {
		root=new BinaryNode<T>(rootData);
	}

	public BinaryTree(T rootData,BinaryTree<T> leftTree,BinaryTree<T> rightTree){
		//		System.out.print(rootData+" ");
		privateSetTree(rootData, leftTree, rightTree);
	}

	private void privateSetTree(T rootData,BinaryTree<T> leftTree,BinaryTree<T> rigthTree){
		root=new BinaryNode<T>(rootData);
		if(leftTree!=null && !leftTree.isEmpty())
			root.setLeftChild(leftTree.root.copy());
		if(rigthTree!=null && !rigthTree.isEmpty())
			root.setRightChild(rigthTree.root.copy());
	}

	@Override
	public T getRootData() {
		T rootData=null;
		if(root!=null)
			rootData=root.getData();
		return rootData;
	}
	//受保护的方法
	protected void setRootData(T rootData){
		root.setData(rootData);
	}

	protected void setRootNode(BinaryNode<T> rootNode){
		root=rootNode;
	}

	protected BinaryNode<T> grtRootNode(){
		return root;
	}

	@Override
	public int getHeight() {
		return root.getHight();
	}

	public int getHeight(BinaryNode<T> rootNode) {
		return root.getHight(rootNode);
	}

	
	@Override
	public int getNumberOfNodes() {
		return root.getNumberOfNodes();
	}

	@Override
	public boolean isEmpty(){
		return root==null;
	}

	@Override
	public void clear() {
		root=null;
	}

	@Override
	public Iterator<T> getPreorderIterator() {
		return new PreorderIterator();
	}

	@Override
	public Iterator<T> getPostorderIterator() {
		return new PostorderIterator();
	}

	@Override
	public Iterator<T> getInorderIterator() {
		return new InorderIterator();
	}

	@Override
	public Iterator<T> getLevelorderIterator(){
		return new LevelorderIterator();
	}

	@Override
	public void display_Inorder() {
		Iterator<T> InorderIterator=(Iterator<T>) getInorderIterator();
		System.out.print("中序迭代器历遍：");
		while(InorderIterator.hasNext())
			System.out.print(InorderIterator.next()+" ");
		System.out.println();
	}

	@Override
	public void display_Preorder() {
		Iterator<T> PreorderIterator=(Iterator<T>) getPreorderIterator();
		System.out.print("先序迭代器历遍：");
		while(PreorderIterator.hasNext())
			System.out.print(PreorderIterator.next()+" ");
		System.out.println();
	}

	@Override
	public void display_Postorder() {
		Iterator<T> PostorderIterator=(Iterator<T>) getPostorderIterator();
		System.out.print("后序迭代器历遍：");
		while(PostorderIterator.hasNext())
			System.out.print(PostorderIterator.next()+" ");
		System.out.println();
	}

	@Override
	public void display_Levelorder() {
		Iterator<T> LevelorderIterator=(Iterator<T>) getLevelorderIterator();
		System.out.print("层序迭代器历遍：");
		while(LevelorderIterator.hasNext())
			System.out.print(LevelorderIterator.next()+" ");
		System.out.println();
	}

	private class PreorderIterator implements Iterator<T>{

		private LinkedStack<BinaryNode<T>> nodeStack;
		private BinaryNode<T> currentNode;

		public PreorderIterator(){
			nodeStack=new LinkedStack<BinaryNode<T>>();
			currentNode=root;
		}

		@Override
		public boolean hasNext(){
			return !nodeStack.isEmpty() || currentNode!=null;
		}

		@Override
		public T next(){
			BinaryNode<T> nextNode=null;
			if(currentNode!=null){
				nodeStack.push(currentNode);
			}
			if(!nodeStack.isEmpty()){
				nextNode=nodeStack.pop();
				if(nextNode.hasRightChild())
					nodeStack.push((BinaryNode<T>) nextNode.getRightChild());
				currentNode=(BinaryNode<T>) nextNode.getLeftChild();
			}
			return nextNode.getData();
		}

		@Override
		public void remove() {
			
		}

	}

	private class InorderIterator implements Iterator<T>{

		private LinkedStack<BinaryNode<T>> nodeStack;
		private BinaryNode<T> currentNode;

		public InorderIterator(){
			nodeStack=new LinkedStack<BinaryNode<T>>();
			currentNode=root;
		}

		@Override
		public boolean hasNext(){
			return !nodeStack.isEmpty() || currentNode!=null;
		}

		@Override
		public T next(){
			BinaryNode<T> nextNode=null;
			while(currentNode!=null){
				nodeStack.push(currentNode);
				currentNode=(BinaryNode<T>) currentNode.getLeftChild();
			}
			if(!nodeStack.isEmpty()){
				nextNode=nodeStack.pop();
				currentNode=(BinaryNode<T>) nextNode.getRightChild();
			}else
				throw new NoSuchElementException();
			return nextNode.getData();
		}

		@Override
		public void remove() {
			
		}

	}

	private class PostorderIterator implements Iterator<T>{

		private LinkedStack<BinaryNode<T>> nodeStack;
		private BinaryNode<T> currentNode;
		private BinaryNode<T> preNode;

		public PostorderIterator(){
			nodeStack=new LinkedStack<BinaryNode<T>>();
			currentNode=root;
			preNode=null;
		}

		@Override
		public boolean hasNext(){
			return !nodeStack.isEmpty() || currentNode!=null;
		}

		@Override
		public T next(){
			BinaryNode<T> nextNode=null;
			while(true){
				if(currentNode!=null){
					nodeStack.push(currentNode);
					currentNode=(BinaryNode<T>) currentNode.getLeftChild();
				}else{
					currentNode=nodeStack.peek();
					if(currentNode.hasRightChild() && preNode!=currentNode.getRightChild())
						currentNode=(BinaryNode<T>) currentNode.getRightChild();
					else
						break;
				}
			}
			currentNode=preNode=nodeStack.pop();
			nextNode=currentNode;
			currentNode=null;
			return nextNode.getData();
		}

		@Override
		public void remove() {
			
		}	
	}

	private class LevelorderIterator implements Iterator<T>{

		private LinkedQueue<BinaryNode<T>> nodeQueue;
		private BinaryNode<T> currentNode;

		public LevelorderIterator() {
			nodeQueue=new LinkedQueue<BinaryNode<T>>();
			nodeQueue.enqueue(root);
		}

		@Override
		public boolean hasNext() {
			return !nodeQueue.isEmpty();
		}

		@Override
		public T next() {
			if(!nodeQueue.isEmpty()){
				currentNode=nodeQueue.dequeue();
				if(currentNode!=null){
					if(currentNode.hasLeftChild())
						nodeQueue.enqueue((BinaryNode<T>) currentNode.getLeftChild());
					if(currentNode.hasRightChild())
						nodeQueue.enqueue((BinaryNode<T>) currentNode.getRightChild());
				}
			}
			return currentNode.getData();
		}

		@Override
		public void remove() {
			
		}
	}
	
	@Override
	public void setTree(T rootData){
		root=new BinaryNode<T>(rootData);
	}

	@Override
	public void setTree(T rootData, BinaryTreeInterface<T> leftTree,BinaryTreeInterface<T> rightTree){
		privateSetTree(rootData, (BinaryTree<T>)leftTree, (BinaryTree<T>)rightTree);
	}
}

（3）代码测试

public class main_BinaryTree {

	private static BinaryTree<Integer> root_tree;
	public static void main(String[] args) {
		
		BinaryTree<Integer> left_tree21=new BinaryTree<Integer>(1,new BinaryTree<Integer>(2),new BinaryTree<Integer>(3));
		BinaryTree<Integer> right_tree22=new BinaryTree<Integer>(4,new BinaryTree<Integer>(5),new BinaryTree<Integer>(6));
		BinaryTree<Integer> left_tree23=new BinaryTree<Integer>(7,new BinaryTree<Integer>(8),new BinaryTree<Integer>(9));
		BinaryTree<Integer> right_tree24=new BinaryTree<Integer>(10,new BinaryTree<Integer>(11),new BinaryTree<Integer>(12));
		BinaryTree<Integer> left_tree11=new BinaryTree<Integer>(13,left_tree21,right_tree22);
		BinaryTree<Integer> right_tree12=new BinaryTree<Integer>(14,left_tree23,right_tree24);
		root_tree=new BinaryTree<Integer>(15,left_tree11,right_tree12);
		root_tree.display_Preorder();
		root_tree.display_Inorder();
		root_tree.display_Postorder();
		root_tree.display_Levelorder();
		System.out.println("根："+root_tree.getRootData()+"; 数高度："+root_tree.getHeight()+"; 节点数："+root_tree.getNumberOfNodes());
	}
}

结果：

先序迭代器历遍：15 13 1 2 3 4 5 6 14 7 8 9 10 11 12 
中序迭代器历遍：2 1 3 13 5 4 6 15 8 7 9 14 11 10 12 
后序迭代器历遍：2 3 1 5 6 4 13 8 9 7 11 12 10 14 15 
层序迭代器历遍：15 13 14 1 4 7 10 2 3 5 6 8 9 11 12 
根：15; 数高度：4; 节点数：15

代码下载