树是编程中一种经常使用的数据结构。之前在学习数据结构时，总想着如何实际地实现出一颗二叉树出来，如今参考了《数据结构与算法分析 JAVA语言描述 第二版》以后，照着书中的例子实现了一颗二叉树，我的感受书上面的二叉树实现操做比较复杂。下面将我学到的一些知识记录下来：html
1，定义树的操做的基本接口，其中不包括插入或删除操做，由于这二种操做与树的结构相关，不一样的树的实现有着不一样的插入与删除方式，故不该该将这二种操做放在接口中让全部的类来实现。同时，接口中也不包括遍历操做，由于并非每一个应用都会用到遍历。咱们能够定义返回一个迭代器的方法，因为树中有多种不一样的遍历，树的类能够含有几个方法，每一个方法返回一种迭代器。java
基本接口中定义了树的经常使用操做，代码以下：node
public interface TreeInterface<T> { public T getRootData(); public int getHeight(); public int getNumberOfNodes(); public boolean isEmpty(); public void clear(); }
2，因为对树的许多操做都少不了遍历，所以须要构造一个可以对树中的元素进行遍历的迭代器。本例中采用内部类的方式来实现迭代器，下面的定义的接口 TreeIteratorInterface 包含了生成不一样迭代器的方法。让实现树的具体的JAVA类 implements TreeIteratorInterface<T>，而后该JAVA类再定义一个内部类 implements Iterator<T>，便可构造一个可以对树中元素进行遍历的迭代器。算法
为何要让实现树的具体的JAVA类 implements TreeIteratorInterface<T>？编程
由于，TreeIteratorInterface<T>接口中定义了返回各类各样迭代器的方法，实现树的具体的JAVA类 的对象就能够调用这些方法得到迭代器了。在后面的例子中，咱们定义了一个具体实现树数据结构的类 BinaryTree<T>，该类 implements BinaryTreeInterface<T>，而 BinaryTreeInterface<T> 又extends TreeIteratorInterface<T>，于是BinaryTree<T>的对象能够调用 TreeIteratorInterface<T>接口中的方法来得到迭代器了。数据结构
关于如何为自定义的数据结构实现迭代器，一个更好的参考例子：http://www.cnblogs.com/hapjin/p/4454594.htmlide
TreeIteratorInterface<T> 的具体代码以下：post
public interface TreeIteratorInterface<T> { public Iterator<T> getPreorderIterator(); public Iterator<T> getPostorderIterator(); public Iterator<T> getInorderIterator(); public Iterator<T> getLevelOrderIterator(); }
3，定义了树的接口以后，因为咱们大部分状况仍是使用二叉树，所以下面定义二叉树的接口。首先，二叉树也是树，所以继承了TreeInterface<T>；其次，二叉树的对象要可以得到迭代器，所以又继承了TreeIteratorInterface<T>。（JAVA中接口容许多重继承）学习
该二叉树接口没有什么特别的操做（大部分基本操做已经从TreeInterface<T>中继承下来了），它只定义了两个方法，这两个方法用来生成二叉树。测试
//JAVA接口能够多继承 public interface BinaryTreeInterface<T> extends TreeInterface<T> ,TreeIteratorInterface<T>{ //如下这两个方法定义了如何构造二叉树 public void setTree(T rootData);//构造一颗以rootData为根的二叉树 //构造一颗以rootData为根,leftTree为左子树，rightTree为右子树的二叉树 public void setTree(T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T> rightTree); }
4，与单链表同样，链表中有链表结点，二叉树中也须要定义表示结点的类。而这里定义的表示结点的类采用独立的外部类实现，而不是采用内部类来实现。
在考虑表示结点的类时，咱们先定义了一个抽象的接口来规定对结点的一些基本操做。（这也是为何我以为书中二叉树实现比较复杂的缘由）
该接口为 BinaryNodeInterface<T>，具体代码以下：
//二叉树结点的接口 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 getHeight();//计算以该结点为根的子树的高度 public BinaryNodeInterface<T> copy();//复制以该结点为根的子树 }
5，接下来即是二叉树的节点的实现类了，该类 implements BinaryNodeInterface<T> 从而实现了接口中定义的各类对节点的操做。
class BinaryNode<T> implements BinaryNodeInterface<T>, java.io.Serializable{ private T data;//结点的数据域 private BinaryNode<T> left;//左孩子 private BinaryNode<T> right;//右孩子 public BinaryNode(){ this(null); } //构造一个值为dataPortaion的结点 public BinaryNode(T dataPortion){ this(dataPortion, null, null); } public BinaryNode(T dataPortion, BinaryNode<T> leftChild, BinaryNode<T> rightChild){ data = dataPortion; left = leftChild; right = rightChild; } @Override //返回结点的数据域的值 public T getData() { return data; } @Override //更改结点数据域的值 public void setData(T newData) { data = newData; } @Override //得到结点的左孩子 public BinaryNodeInterface<T> getLeftChild() { return left; } @Override //得到结点的右孩子 public BinaryNodeInterface<T> getRightChild() { return right; } @Override //更改结点的左孩子 public void setLeftChild(BinaryNodeInterface<T> leftChild) { left = (BinaryNode<T>)leftChild; } @Override //更改结点的右孩子 public void setRightChild(BinaryNodeInterface<T> rightChild) { 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 getHeight() { return getHeight(this); } private int getHeight(BinaryNode<T> node){ int height = 0; if(node != null) height = 1 + Math.max(getHeight(node.left), getHeight(node.right)); return height; } @Override //该方法被构造二叉树的setTree()方法调用 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; } }
6，二叉树的节点也定义好了，是时候实现二叉树了（好麻烦啊啊啊）。上面已经谈到，BinaryTree<T>实现了一颗具体的二叉树，而且经过定义了一个内部类来生成迭代器。这里就简要介绍下这个实现迭代器的内部类：该内部类名为 private class InorderIterator<T> implements Iterator<T>
这里，进行了一些偷懒，即下面的代码中只实现了可以对树进行中序遍历的迭代器即InorderIterator。固然了，你还能够再定义一个内部类PreorderIterator，而后按照先序遍历采用迭代的方法来实现先序遍历的迭代器。
下面正式介绍私有内部类InorderIterator<T>，因为它 implements Iterator<T>，所以须要实现Iterator<T>中定义的三个抽象方法，这三个方法就是用来完成迭代的（遍历的）。咱们按照中序遍历（非递归方式）的逻辑来实现这三个方法。中序遍历（非递归方式）须要栈来辅助存储结构，所以，代码中定义了一个顺序栈来保存遍历过程当中遇到的结点，而该顺序栈的实现请参考另外一篇博文：http://www.cnblogs.com/hapjin/p/4442729.html
实现二叉树的BinaryTree<T>代码以下：
import java.util.Iterator; import java.util.NoSuchElementException; import list.SequenceStack;//SequenceStack在list包中 import list.Stack;//Stack接口在list包中 public class BinaryTree<T> implements BinaryTreeInterface<T>, java.io.Serializable{ private BinaryNodeInterface<T> root;//树根结点 private class InorderIterator<T> implements Iterator<T>{ //定义一个顺序栈nodeStack来存放遍历过程当中遇到的结点 private Stack<BinaryNodeInterface<T>>nodeStack;//list包中有顺序栈的实现 private BinaryNodeInterface<T> currentNode; public InorderIterator(){ nodeStack = new SequenceStack<BinaryNodeInterface<T>>(); currentNode = (BinaryNodeInterface<T>) root;//此处为何须要强制转换呢？ } /* * 按照中序遍历的逻辑进行实现Iterator接口中的方法，从而实现一个迭代器 */ @Override public boolean hasNext() { return (!nodeStack.empty()) || (currentNode != null); } @Override public T next() { BinaryNodeInterface<T> nextNode = null; while(currentNode != null){ nodeStack.push(currentNode); currentNode = currentNode.getLeftChild(); } if(!nodeStack.empty()){ nextNode = nodeStack.pop(); assert nextNode != null; currentNode = nextNode.getRightChild(); } else throw new NoSuchElementException(); return nextNode.getData(); } @Override //仅仅是完成遍历的功能，删除功能是不须要有的。 public void remove() { throw new UnsupportedOperationException(); } } public BinaryTree(){ root = null; } public BinaryTree(T rootData){ root = new BinaryNode<T>(rootData); } public BinaryTree(T rootData, BinaryTree<T> leftTree, BinaryTree<T> rightTree){ privateSetTree(rootData, leftTree, rightTree); } @Override public void setTree(T rootData) { root = new BinaryNode<T>(rootData); } @Override /* *以rootData为根，leftTree为左子树，rightTree为右子树 *生成一颗新的二叉树，setTree()实际调用了privateSetTree()来构造二叉树 */ public void setTree(T rootData, BinaryTreeInterface<T> leftTree, BinaryTreeInterface<T> rightTree) { privateSetTree(rootData, (BinaryTree)leftTree, (BinaryTree)rightTree); } private void privateSetTree(T rootData, BinaryTree<T>leftTree, BinaryTree<T> rightTree){ root = new BinaryNode<T>(rootData); if((leftTree != null) && (!leftTree.isEmpty())) root.setLeftChild(leftTree.root); if((rightTree != null) && (!rightTree.isEmpty())){ if(rightTree != leftTree) root.setRightChild(rightTree.root); else root.setRightChild(rightTree.root.copy()); } if((leftTree != null) && (leftTree != this)) leftTree.clear(); if((rightTree != null) && (rightTree != this)) rightTree.clear(); } //更改根结点的数据域 protected void setRootData(T rootData){ root.setData(rootData); } //更改根结点 protected void setRootNode(BinaryNodeInterface<T> rootNode){ root = rootNode; } protected BinaryNodeInterface<T> getRootNode(){ return root; } @Override //返回树的根节点的数据域 public T getRootData() { T rootData = null; if(root != null) rootData = root.getData();//调用节点的getData(),返回该节点的数据域 return rootData; } @Override //返回二叉树的高度 public int getHeight() { return root.getHeight();//二叉树的高度即为以根结点为根的子树的高度 } @Override //返回二叉树中结点的个数 public int getNumberOfNodes() { return root.getNumberOfNodes(); } @Override public boolean isEmpty() { return root == null; } @Override public void clear() { root = null; } //中序遍历二叉树 public void inorderTraverse(){ inorderTraverse(root); } private void inorderTraverse(BinaryNodeInterface<T> node){ if(node != null){ inorderTraverse((BinaryNode)node.getLeftChild()); System.out.println(node.getData());//若使用迭代器，能够在测试程序中输出，而不是在这里使用输出语句 inorderTraverse((BinaryNode)node.getRightChild()); } } public void preorderTraverse(){ preorderTraverse(root); } private void preorderTraverse(BinaryNodeInterface<T> node){ if(node != null){ System.out.println(node.getData()); preorderTraverse((BinaryNode)node.getLeftChild()); preorderTraverse((BinaryNode)node.getRightChild()); } } public void postorderTraverse(){ postorderTraverse(root); } private void postorderTraverse(BinaryNodeInterface<T> node){ if(node != null){ postorderTraverse((BinaryNode)node.getLeftChild()); postorderTraverse((BinaryNode)node.getRightChild()); System.out.println(node.getData()); } } @Override //得到先序遍历器的方法，因为在该类中没有定义生成先序迭代器的私有内部类，所以该方法为空实现 public Iterator<T> getPreorderIterator() { // TODO Auto-generated method stub return null; } @Override //得到后序遍历器的方法，因为在该类中没有定义生成后序迭代器的私有内部类，所以该方法为空实现 public Iterator<T> getPostorderIterator() { // TODO Auto-generated method stub return null; } @Override public Iterator<T> getInorderIterator() { return new InorderIterator(); } @Override //得到层次遍历器的方法，因为在该类中没有定义生成层次迭代器的私有内部类，所以该方法为空实现 public Iterator<T> getLevelOrderIterator() { // TODO Auto-generated method stub return null; } }