二叉树(3)——三叉链表示的二叉树

三叉链表示的二叉树定义

所畏的三叉链表示是指二叉树由指向左孩子结点、右孩子结点、父亲结点【三叉】的引用（指针）数据和数据组成。

package datastructure.tree.btree;
/**
 * 三叉链表示的二叉树定义
 * @author Administrator
 *
 */
public class BinTreeNode{
	private Object data; // 数据域
	private BinTreeNode parent; // 父节点
	private BinTreeNode lChild; // 左孩子
	private BinTreeNode rChild; // 右孩子
	private int height; // 以该节点为根的子树的高度
	private int size; // 该节点子孙数（包括结点本身）

	public BinTreeNode() {
		this(null);
	}

	public BinTreeNode(Object e) {
		data = e;
		height = 0;
		size = 1;
		parent = lChild = rChild = null;
	}
	//************ Node接口方法 *************/	
	/**
	 *  获得结点的数据 
	 */
	public Object getData() {
		return data;
	}
	
	public void setData(Object obj) {
		data = obj;
	}
	

	//-------------辅助方法，判断当前结点位置的情况------------
	/**
	 * 判断是否有父亲
	 * @return
	 */
	public boolean hasParent() {
		return parent != null;
	}
	
	/**
	 *  判断是否有左孩子
	 * @return 如果有左孩子结点返回true,否则返回false
	 */
	public boolean hasLChild() {
		return null != lChild;
	}

	/**
	 *  判断是否有右孩子
	 * @return
	 */
	public boolean hasRChild() {
		return null != rChild;
	}

	/**
	 *  判断是否为叶子结点
	 * @return
	 */
	public boolean isLeaf() {
		return (!hasLChild() && !hasRChild());
	}

	/**
	 *  判断是否为某节点的左孩子
	 * @return
	 */
	public boolean isLChild() {
		return (hasParent() && this == parent.lChild);
	}

	/**
	 *  判断是否为某结点的右孩子
	 * @return
	 */
	public boolean isRChild() {
		return (hasParent()) && this == parent.rChild;
	}
	
	//-------------- 与height相关的方法-----------------	
	/**
	 * 取结点的高度，即以该节点为根的树的高度
	 * @return
	 */
	public int getHeight() {
		return height;
	}
	
	/**
	 *  更新当前结点及其祖先的高度
	 */
	public void updateHeight() {
		int newH = 0;// 新高度初始化为0，高度等于左右子树加1中的较大值
		if (hasLChild())
			newH = Math.max(newH, (lChild.getHeight() + 1));// //////////////???
		if (hasRChild())
			newH = Math.max(newH, (rChild.getHeight() + 1));// 先0和左孩子的高度加1进行比较，后左孩子高度加1和右孩子高度加1进行比较
		if (newH == height)
			return; // 高度没有发生变化则直接返回
		height = newH; // 否则，更新高度
		if (hasParent()) // 递归更新祖先的高度
			parent.updateHeight();
	}

	/********* 与size相关的方法 **********/
	/**
	 *  取以该节点为根的树的结点数
	 * @return
	 */
	public int getSize() {
		return size;
	}

	/**
	 *  更新当前结点及祖先的子孙数
	 */
	public void updateSize() {
		size = 1; // 初始化为1，结点本身
		if (hasLChild())
			size = size + lChild.getSize(); // 加上左子树的规模
		if (hasRChild())
			size = size + rChild.getSize(); // 加上右子树的规模
		if (hasParent())
			parent.updateSize();
	}

	/********** 与parent相关的方法 **********/
	/**
	 *  取父节点
	 * @return
	 */
	public BinTreeNode getParent() {
		return parent;
	}

	/**
	 *  断开与父亲的关系
	 */
	public void sever() {
		if (!hasParent())
			return;
		if (isLChild())
			parent.lChild = null;
		else
			parent.rChild = null;
		parent.updateHeight(); // 更新父节点及其祖先的高度
		parent.updateSize(); // 更新父节点及其祖先的规模
		parent = null;
	}

	//********** 与lChild相关的方法 ********/
	/**
	 *  取左孩子
	 * @return
	 */
	public BinTreeNode getLChild() {
		return lChild;
	}

	/**
	 *  设置当前结点的左孩子，返回原左孩子
	 * @param lc
	 * @return
	 */
	public BinTreeNode setLChild(BinTreeNode lc) {
		BinTreeNode oldLC = this.lChild;
		if (hasLChild()) {
			lChild.sever();
		} // 断开当前左孩子与结点的关系
		if (null != lc) {
			lc.sever(); // 判断lc与其父节点的关系
			this.lChild = lc; // 确定父子关系
			lc.parent = this;
			this.updateHeight(); // 更新当前结点及其祖先的高度
			this.updateSize(); // 更新当前结点及其祖先的规模
		}
		return oldLC; // 返回原左孩子
	}

	//********** 与rChild相关的方法 *********/
	/**
	 *  取右孩子
	 * @return
	 */
	public BinTreeNode getRChild() {
		return rChild;
	}

	/**
	 *  设置当前结点为右孩子，返回原右孩子
	 * @param rc
	 * @return
	 */
	public BinTreeNode setRChild(BinTreeNode rc) {
		BinTreeNode oldRC = this.rChild;
		if (hasRChild()) {
			rChild.sever();
		} // 断开当前右孩子与结点的关系
		if (null != rc) {
			rc.sever(); // 断开rc与其父节点的关系
			this.rChild = rc; // 确定父子关系
			rc.parent = this;
			this.updateHeight(); // 更新当前结点及其祖先的高度
			this.updateSize(); // 更新当前结点及其祖先的规模
		}
		return oldRC; // 返回原右孩子
	}
	/**
	 * 重写toString方法
	 */
	public String toString() {
		return "" + data;
	}

}

三叉链表示的二叉树的遍历

package datastructure.tree.btree;

import java.util.*;

import datastructure.common.Strategy;

import datastructure.queue.Queue;
import datastructure.queue.ArrayQueue;
/**
 * 三叉链表示的二叉树的遍历
 * @author luoweifu
 *
 */
public class BinaryTreeOrder {
	private int leafSize = 0;
	private BinTreeNode root = null;
	Strategy strategy = new StrategyEqual();
	
	/**
	 * 构造函数，传入树的根结点
	 * @param node
	 *            树的根结点
	 */
	public BinaryTreeOrder(BinTreeNode node) {
		this.root = node;
		Strategy strategy = new StrategyEqual();
	}
	
	public BinTreeNode getRoot() {
		return root;
	}

	/**
	 * 前序遍历
	 * 
	 * @return 返回一个Iterator容器
	 */
	public Iterator preOrder() {
		List<BinTreeNode> list = new LinkedList();
		preOrderRecursion(this.root, list);
		return list.iterator();
	}

	/**
	 * 递归定义前序遍历
	 * @param rt
	 *            树根结点
	 * @param list
	 *            LinkedList容器
	 */
	private void preOrderRecursion(BinTreeNode rt, List list) {
		if (null == rt)
			return; // 递归基，空树直接返回
		list.add(rt); // 访问根节点
		preOrderRecursion(rt.getLChild(), list);// 遍历左子树
		preOrderRecursion(rt.getRChild(), list);// 遍历右子树
	}

	/**
	 * 中序遍历
	 * 
	 * @return
	 */
	public Iterator inOrder() {
		List<BinTreeNode> list = new LinkedList();
		inOrderRecursion(this.root, list);
		return list.iterator();
	}

	/**
	 * 递归定义中序遍历
	 * @param rt
	 *            树根结点
	 * @param list
	 *            LinkedList容器
	 */
	private void inOrderRecursion(BinTreeNode rt, List list) {
		if (null == rt)
			return; // 递归基，空树直接返回
		inOrderRecursion(rt.getLChild(), list);// 遍历左子树
		list.add(rt); // 访问根节点
		inOrderRecursion(rt.getRChild(), list);// 遍历右子树
	}

	/**
	 *  后序遍历
	 * @return
	 */
	public Iterator postOrder() {
		List<BinTreeNode> list = new LinkedList();
		postOrderRecursion(this.root, list);
		return list.iterator();
	}
	
	/**
	 * 递归定义后序遍历
	 * @param rt
	 *            树根结点
	 * @param list
	 *            LinkedList容器
	 */
	private void postOrderRecursion(BinTreeNode rt, List list) {
		if (null == rt)
			return; // 递归基，空树直接返回
		postOrderRecursion(rt.getLChild(), list);// 遍历左子树
		postOrderRecursion(rt.getRChild(), list);// 遍历右子树
		list.add(rt);// 访问根节点
	}

	/**
	 *  按层遍历
	 * @return
	 */
	public Iterator levelOrder() {
		List<BinTreeNode> list = new LinkedList();
		levelOrderTraverse(this.root, list);
		return list.iterator();
	}

	/**
	 *  使用队列完成二叉树的按层遍历
	 * @param rt
	 * @param list
	 */
	private void levelOrderTraverse(BinTreeNode rt, List list) {
		if (null == rt)
			return;
		Queue q = new ArrayQueue();
		q.push(rt);// 根节点入队列
		while (!q.isEmpty()) {
			BinTreeNode p = (BinTreeNode) q.deQueue(); // 取出队首节点p并访问
			list.add(p);
			if (p.hasLChild())
				q.push(p.getLChild()); // 将p的非空左右孩子依次入队列
			if (p.hasRChild())
				q.push(p.getRChild());
		}
	}

	/**
	 *  在树中查找元素e，并返回其所在的结点
	* @param e 要查找的数据元素
	 * @return 返回找到的结点
	 */
	public BinTreeNode find(Object e) {
		return searchE(root, e);
	}

	/**
	 * 递归查找元素e
	 * @param rt 树的根
	 * @param e 要查找的数据元素
	 * @return 返回找到的结点
	 */
	private BinTreeNode searchE(BinTreeNode rt, Object e) {
		if (null == rt)
			return null;
		if (strategy.equal(rt.getData(), e))
			return rt;
		BinTreeNode v = searchE(rt.getLChild(), e);
		if (null == v)
			v = searchE(rt.getRChild(), e);
		return v;
	}
	/**
	 * 打印二叉树
	 * @return
	 */
	public String printBinTree() {
		StringBuilder sb = new StringBuilder();
		printBinTree(root, 0, sb);
		return sb.toString();
	}

	/**
	 * 打印二叉树
	 * @param btree 根结点
	 * @param n 结点层数
	 * @param sb 用于保存记录的字符串
	 */
	private void printBinTree(BinTreeNode btree, int n, StringBuilder sb) {
		if (null == btree)
			return;
		printBinTree(btree.getRChild(), n + 1, sb);
		for (int i = 0; i < n; i++)
			sb.append("\t");
		if (n >= 0)
			sb.append(btree.getData() + "\n");
		printBinTree(btree.getLChild(), n + 1, sb);
	}

	 /**
	  * 求叶结点的个数
	  * @return 叶结点的个数
	  */
	public int sizeLeaf() {
		searchLeaf(this.root);
		return leafSize;
	}
	/**
	 * 叶结点的个数
	 * @param rt
	 */
	private void searchLeaf(BinTreeNode rt) {
		if (null == rt)
			return;
		if (rt.isLeaf())
			leafSize++;
		else {
			searchLeaf(rt.getLChild());
			searchLeaf(rt.getRChild());
		}
	}

}

测试

package datastructure.tree.btree;

import java.util.Iterator;

public class BTreeTest2 {
	// 测试功能
	// 结果：所有功能都能实现，正确
	public static void main(String args[]) {
		//构造二叉树
		BinTreeNode roots = new BinTreeNode();
		BinTreeNode node = new BinTreeNode();
		roots.setData('A');
		roots.setLChild(new BinTreeNode('B'));
		roots.setRChild(new BinTreeNode('C'));
		node = roots.getLChild();
		node.setLChild(new BinTreeNode('D'));
		node.setRChild(new BinTreeNode('E'));
		node = roots.getRChild();
		node.setLChild(new BinTreeNode('F'));
		BinaryTreeOrder order = new BinaryTreeOrder(roots);
		//------遍历--------
		Iterator<BinTreeNode> iter1 = order.preOrder();
		System.out.println("前序遍历：");
		printIterator(iter1);
		
		Iterator<BinTreeNode> iter2 = order.inOrder();
		System.out.println("中序遍历：");
		printIterator(iter2);
		
		Iterator<BinTreeNode> iter3 = order.postOrder();
		System.out.println("后序遍历：");
		printIterator(iter3);
		
		Iterator<BinTreeNode> iter4 = order.levelOrder();
		System.out.println("层次遍历：");
		printIterator(iter4);
				
		String str = order.printBinTree();
		System.out.println("打印二叉树：\n" + str);
		System.out.println("叶结点的个数：" + order.sizeLeaf()); 
		BinTreeNode nodeone = order.find('E'); 
		System.out.println("根结点的数据元素：" + nodeone.getData());
	}
	public static void printIterator(Iterator<BinTreeNode> iter) {
		while(iter.hasNext()) {
			System.out.print("\t" + iter.next().getData());
		}
		System.out.println();
	}
	
}

结果：

前序遍历：
A BD E C F
中序遍历：
D BE A F C
后序遍历：
D EB F C A
层次遍历：
A BC D E F
打印二叉树：
C
F
A
E
B
D


叶结点的个数：3
根结点的数据元素：E