数据结构—树
树
树 由显示结点间关系的边相联而成的结点集合。如下图
树的根与任意其他结点之间的路径是唯一的。
树的高度是树中层的数目,该高度也等于根与叶子间最长路径上的结点数目。
上图是一棵三叉树,因为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
代码下载
中序迭代器历遍: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