【Java】大话数据结构(9) 树（二叉树、线索二叉树）

本文根据《大话数据结构》一书，对Java版的二叉树、线索二叉树进行了一定程度的实现。

另：

二叉排序树（二叉搜索树）

平衡二叉树(AVL树)

二叉树的性质

性质1：二叉树第i层上的结点数目最多为 2^{i-1}(i≥1)。

性质2：深度为k的二叉树至多有2^{k}-1个结点(k≥1)。

性质3：在任意一棵二叉树中，若终端结点的个数为n₀，度为2的结点数为n₂，则n₀=n₂+1。

　　　　证明提示：分支线总数=n₀+n₁+n₂-1=n₁+2×n₂

性质4：具有n个节点的完全二叉树的深度为[log₂n]+1。（[ ]代表向下取整）

　　　　证明提示：假设深度为k，则有2^{k-1}-1＜n≤2^{k}-1。

性质5：如果有一颗有n个节点的完全二叉树的节点按层次序编号，对任一层的节点i（1<=i<=n）有

1.如果i=1，则节点是二叉树的根，无双亲，如果i>1，则其双亲节点为[i/2]

2.如果2i>n那么节点i没有左孩子（叶子结点），否则其左孩子为2i

3.如果2i+1>n那么节点没有右孩子，否则右孩子为2i+1

二叉链表的定义代码

class BiTNode<E>{

	E data;

	BiTNode<E> lchild,rchild;

	public BiTNode(E data) {

		this.data=data;

		this.lchild=null;

		this.rchild=null;

	}

}

public class BiTree<E> {

	private BiTNode<E> root;

	public BiTree() {

		root=null;

	}

        ...

}

二叉树的遍历

	/*

	 * 前序遍历

	 */

	public void preOrder() {

		preOrderTraverse(root);

		System.out.println();

	}

	private void preOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		System.out.print(node.data);

		preOrderTraverse(node.lchild);

		preOrderTraverse(node.rchild);

	}

	/*

	 * 中序遍历

	 */

	public void inOrder() {

		inOrderTraverse(root);

		System.out.println();

	}

	private void inOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		inOrderTraverse(node.lchild);

		System.out.print(node.data);

		inOrderTraverse(node.rchild);

	}

	/*

	 * 后序遍历

	 */

	public void postOrder() {

		postOrderTraverse(root);

		System.out.println();

	}

	private void postOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		postOrderTraverse(node.lchild);

		postOrderTraverse(node.rchild);

		System.out.print(node.data);

	}

二叉树的建立

　　《大话》一书中，6.9节关于二叉树的建立如下：

　　通过输入AB#D##C##，可以生成上述二叉树，其C语言的实现算法如下：

　　暂时能力有限，还不懂如何改为Java代码。

　　几点疑问：1.exit(OVERFLOW)不是很清楚什么意思；

　　　　　　　2.代码中为char类型，如何用于泛型？

　　　　　　 3.scanf()在Java中怎么实现？用scanner吗？程序如何知道输入完“AB#D##C##”就结束二叉树的构造呢？总的实现代码（包括main部分）是怎么样的？

以下为测试代码遍历的总体测试代码：

package BiTree;

class BiTNode<E>{

	E data;

	BiTNode<E> lchild,rchild;

	public BiTNode(E data) {

		this.data=data;

		this.lchild=null;

		this.rchild=null;

	}

}

public class BiTree<E> {

	private BiTNode<E> root;

	public BiTree() {

		//root=new BiTNode(null, null, null);

		root=null;

	}

	/*

	 * 前序遍历

	 */

	public void preOrder() {

		preOrderTraverse(root);

		System.out.println();

	}

	private void preOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		System.out.print(node.data);

		preOrderTraverse(node.lchild);

		preOrderTraverse(node.rchild);

	}

	/*

	 * 中序遍历

	 */

	public void inOrder() {

		inOrderTraverse(root);

		System.out.println();

	}

	private void inOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		inOrderTraverse(node.lchild);

		System.out.print(node.data);

		inOrderTraverse(node.rchild);

	}

	/*

	 * 后序遍历

	 */

	public void postOrder() {

		postOrderTraverse(root);

		System.out.println();

	}

	private void postOrderTraverse(BiTNode<E> node) {

		if(node==null)

			return;

		postOrderTraverse(node.lchild);

		postOrderTraverse(node.rchild);

		System.out.print(node.data);

	}

	/*

	 * 6.9 二叉树的建立暂时不会,略

	 */

	public static void main(String[] args) {

		BiTree<String> aBiTree = new BiTree<String>();

		aBiTree.root=new BiTNode("A");

		aBiTree.root.lchild=new BiTNode("B");

		aBiTree.root.rchild=new BiTNode("C");

		aBiTree.root.lchild.rchild=new BiTNode("D");

		System.out.println("————前序————");

		aBiTree.preOrder();

		System.out.println("————中序————");

		aBiTree.inOrder();

		System.out.println("————后序————");

		aBiTree.postOrder();

	}

}

————前序————

ABDC

————中序————

BDAC

————后序————

DBCA

BiTree

线索二叉树

　　对一个有n个节点的二叉链表（如上图），整表存在2n个指针域，但分支线只有n-1条，说明空指针域的个数为2n-(n-1) = n+1个，浪费了很多的内存资源。

　　我们可以通过利用这些空指针域，存放节点在某种遍历方式下的前驱和后继节点的指针。我们把这种指向前驱和后继的指针成为线索，加上线索的二叉链表成为线索链表，对应的二叉树就成为“线索二叉树(Threaded Binary Tree)”，如下图所示。

　　线索二叉树的Java代码如下：

package BiThrTree;

/**

 * 线索二叉树

 * 包含二叉树的中序线索化及其遍历

 * @author Yongh

 *

 */

class BiThrNode<E>{

	E data;

	BiThrNode<E> lChild,rChild;

	boolean lTag,rTag;

	public BiThrNode(E data) {

		this.data=data;

		//tag都先定义成左右孩子指针。

		lTag=false;  //其实把Tag定义为IsThread更好

		rTag=false;

		lChild=null;

		rChild=null;

	}

}

public class BiThrTree<T> {

	BiThrNode<T> root;

	boolean link=false,thread=true;

	public BiThrTree() {

		root=null;

	}

	/*

	 * 中序线索化二叉树

	 * 即：在遍历的时候找到空指针进行修改。

	 */

	BiThrNode<T> pre;	//线索化时记录的前一个结点

	public void inThreading() {

		inThreading(root);

	}

	private void inThreading(BiThrNode<T> p) {

		if(p != null) {

			inThreading(p.lChild);

			if(p.lChild==null) {

				p.lTag=thread;

				p.lChild=pre;

			}

			if(pre!=null && pre.rChild==null) {  //pre!=null一定要加上

				pre.rTag=thread;

				pre.rChild=p;

			}

			pre=p;                               //别忘了在这个位置加上pre=p

			inThreading(p.rChild);

		}

	}

	/*

	 * 中序遍历二叉线索链表表示的二叉树(按后继方式)

	 * 书中添加了一个头结点，本程序中不含头结点

	 * 思路：先找到最左子结点

	 */

	public void inOrderTraverse() {

		BiThrNode<T> p = root;

		while(p!=null) {

			while(p.lTag==link)

				p=p.lChild;    //找到最左子结点

			System.out.print(p.data);

			while(p.rTag==thread) {   //不是if

				p=p.rChild;

				System.out.print(p.data);

			}

			p=p.rChild;

		}

		System.out.println();

	}

	/*

	 * 中序遍历方法二(按后继方式)

	 * 参考别人的博客

	 */

	public void inOrderTraverse2() {

		BiThrNode<T> node = root;

        while(node != null && node.lTag==link) {

            node = node.lChild;

        }

        while(node != null) {

            System.out.print(node.data + ", ");

            if(node.rTag==thread) {//如果右指针是线索

                node = node.rChild;

            } else {    //如果右指针不是线索，找到右子树开始的节点

                node = node.rChild;

                while(node != null && node.lTag==link) {

                    node = node.lChild;

                }

            }

        }

        System.out.println();

	}

	public static void main(String[] args) {

		BiThrTree<String> aBiThrTree = new BiThrTree<String>();

		aBiThrTree.root=new BiThrNode<String>("A");					//		A

		aBiThrTree.root.lChild=new BiThrNode<String>("B");			//    /   \

		aBiThrTree.root.lChild.lChild=new BiThrNode<String>("C");	    //	 B     D

		aBiThrTree.root.rChild=new BiThrNode<String>("D");			//  /     / \

		aBiThrTree.root.rChild.lChild=new BiThrNode<String>("E");     // C     E   F

		aBiThrTree.root.rChild.rChild=new BiThrNode<String>("F");

		aBiThrTree.inThreading();

		aBiThrTree.inOrderTraverse();

		aBiThrTree.inOrderTraverse2();

	}

}

CBAEDF

C, B, A, E, D, F,

BiThrTree

赫夫曼树及其应用

　　带权路径长度WPL最小的二叉树称为最优二叉树，也称为赫夫曼树(Huffman Tree)。

　　赫夫曼编码：

　　推荐阅读：哈夫曼树(三)之 Java详解