import java.util.*;
public class ThreeLinkBinTree<E>
{
public static class TreeNode
{
Object data;
TreeNode left;
TreeNode right;
TreeNode parent;
public TreeNode()
{
}
public TreeNode(Object data)
{
this.data = data;
}
public TreeNode(Object data , TreeNode left
, TreeNode right , TreeNode parent)
{
this.data = data;
this.left = left;
this.right = right;
this.parent = parent;
}
public String toString()
{
return data.toString();
}
}
private TreeNode root;
//以默认的构造器来创建二叉树
public ThreeLinkBinTree()
{
this.root = new TreeNode();
}
//以指定根元素来创建二叉树
public ThreeLinkBinTree(E data)
{
this.root = new TreeNode(data);
}
/**
* 为指定节点添加子节点。
* @param index 需要添加子节点的父节点的索引
* @param data 新子节点的数据
* @param isLeft 是否为左节点
* @return 新增的节点
*/
public TreeNode addNode(TreeNode parent , E data
, boolean isLeft)
{
if (parent == null)
{
throw new RuntimeException(parent +
"节点为null,无法添加子节点");
}
if (isLeft && parent.left != null)
{
throw new RuntimeException(parent +
"节点已有左子节点,无法添加左子节点");
}
if (!isLeft && parent.right != null)
{
throw new RuntimeException(parent +
"节点已有右子节点,无法添加右子节点");
}
TreeNode newNode = new TreeNode(data);
if (isLeft)
{
//让父节点的left引用指向新节点
parent.left = newNode;
}
else
{
//让父节点的left引用指向新节点
parent.right = newNode;
}
//让新节点的parent引用到parent节点
newNode.parent = parent;
return newNode;
}
//判断二叉树是否为空。
public boolean empty()
{
//根据根元素来判断二叉树是否为空
return root.data == null;
}
//返回根节点。
public TreeNode root()
{
if (empty())
{
throw new RuntimeException("树为空,无法访问根节点");
}
return root;
}
//返回指定节点(非根节点)的父节点。
public E parent(TreeNode node)
{
if (node == null)
{
throw new RuntimeException(node +
"节点为null,无法访问其父节点");
}
return (E)node.parent.data;
}
//返回指定节点(非叶子)的左子节点。当左子节点不存在时返回null
public E leftChild(TreeNode parent)
{
if (parent == null)
{
throw new RuntimeException(parent +
"节点为null,无法添加子节点");
}
return parent.left == null ? null : (E)parent.left.data;
}
//返回指定节点(非叶子)的右子节点。当右子节点不存在时返回null
public E rightChild(TreeNode parent)
{
if (parent == null)
{
throw new RuntimeException(parent +
"节点为null,无法添加子节点");
}
return parent.right == null ? null : (E)parent.right.data;
}
//返回该二叉树的深度。
public int deep()
{
//获取该树的深度
return deep(root);
}
//这是一个递归方法:每棵子树的深度为其所有子树的最大深度 + 1
private int deep(TreeNode node)
{
if (node == null)
{
return 0;
}
//没有子树
if (node.left == null
&& node.right == null)
{
return 1;
}
else
{
int leftDeep = deep(node.left);
int rightDeep = deep(node.right);
//记录其所有左、右子树中较大的深度
int max = leftDeep > rightDeep ?
leftDeep : rightDeep;
//返回其左右子树中较大的深度 + 1
return max + 1;
}
}
//实现先序遍历
public List<TreeNode> preIterator()
{
return preIterator(root);
}
private List<TreeNode> preIterator(TreeNode node)
{
List<TreeNode> list = new ArrayList<TreeNode>();
//处理根节点
list.add(node);
//递归处理左子树
if (node.left != null)
{
list.addAll(preIterator(node.left));
}
//递归处理右子树
if (node.right != null)
{
list.addAll(preIterator(node.right));
}
return list;
}
//实现中序遍历
public List<TreeNode> inIterator()
{
return inIterator(root);
}
private List<TreeNode> inIterator(TreeNode node)
{
List<TreeNode> list = new ArrayList<TreeNode>();
//递归处理左子树
if (node.left != null)
{
list.addAll(inIterator(node.left));
}
//处理根节点
list.add(node);
//递归处理右子树
if (node.right != null)
{
list.addAll(inIterator(node.right));
}
return list;
}
public List<TreeNode> postIterator()
{
return postIterator(root);
}
//实现后序遍历
private List<TreeNode> postIterator(TreeNode node)
{
List<TreeNode> list = new ArrayList<TreeNode>();
//递归处理左子树
if (node.left != null)
{
list.addAll(postIterator(node.left));
}
//递归处理右子树
if (node.right != null)
{
list.addAll(postIterator(node.right));
}
//处理根节点
list.add(node);
return list;
}
//广度优先遍历
public List<TreeNode> breadthFirst()
{
Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
List<TreeNode> list = new ArrayList<TreeNode>();
if( root != null)
{
//将根元素加入“队列”
queue.offer(root);
}
while(!queue.isEmpty())
{
//将该队列的“队尾”的元素添加到List中
list.add(queue.peek());
TreeNode p = queue.poll();
//如果左子节点不为null,将它加入“队列”
if(p.left != null)
{
queue.offer(p.left);
}
//如果右子节点不为null,将它加入“队列”
if(p.right != null)
{
queue.offer(p.right);
}
}
return list;
}
public static void main(String[] args)
{
ThreeLinkBinTree<String> binTree = new ThreeLinkBinTree("根节点");
//依次添加节点
ThreeLinkBinTree.TreeNode tn1 = binTree.addNode(binTree.root()
, "二左" , true);
ThreeLinkBinTree.TreeNode tn2 = binTree.addNode(binTree.root()
, "二右" ,false );
ThreeLinkBinTree.TreeNode tn3 = binTree.addNode(tn1
, "三左" , true);
ThreeLinkBinTree.TreeNode tn4 = binTree.addNode(tn1
, "三右" , false);
ThreeLinkBinTree.TreeNode tn5 = binTree.addNode(tn3
, "四右" , false);
ThreeLinkBinTree.TreeNode tn6 = binTree.addNode(tn5
, "五左" , true);
ThreeLinkBinTree.TreeNode tn7 = binTree.addNode(tn5
, "五右" , false);
System.out.println(binTree.preIterator());
System.out.println(binTree.inIterator());
System.out.println(binTree.postIterator());
System.out.println(binTree.breadthFirst());
}
}