实习报告十一Word格式文档下载.docx

实习报告十一Word格式文档下载.docx

《实习报告十一Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《实习报告十一Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。

YN

输出该节点的数据

输出结束

递归输出其左，右子树

3.【算法设计】

文字说明：

（1）.首先取链表元素判断链表是否为空。

（2）.链表非空先输出该结点的值，在递归调用该方法输出其左右子树。

（3）.链表为空则结束，结束退出。

4.【高级语言代码】

///按前序遍历方式输出二叉树

publicvoidpreOrderTraverse（BinTreeNodep）{

if（p!

=null）{//输出根结点数据域

System.out.print（"

"

+p.GetData（））;

//递归输出p的左子树

preOrderTraverse（p.leftChild）;

//递归输出p的右子树

preOrderTraverse（p.rightChild）;

}

}

（三）、程序中类的设计

“BinTreeNode”类：

1.【逻辑结构与存储结构】

二叉链表也可以带头结点的方式存放，如图（b）所示。

2.【主要成员变量说明】

privateintdata;

//结点数据域

BinTreeNodeleftChild;

//结点左右指针域

BinTreeNoderightChild;

3.【主要成员方法说明】

//构造函数：

一个叶子结点

publicBinTreeNode（intitem）

一个非叶子结点

publicBinTreeNode（intitem,

BinTreeNodeleft,BinTreeNoderight）

//给一个结点赋值

publicvoidSetNode（intitem,

//返回结点数据域的值

publicintGetData（）

4.【高级语言代码】

//定义“二叉链表结点”类

classBinTreeNode{

publicBinTreeNode（intitem）{

data=item;

//左右指针域自动为null

BinTreeNodeleft,BinTreeNoderight）{

leftChild=left;

rightChild=right;

publicintGetData（）{

returndata;

}

}//定义“二叉链表结点”类完毕

“ExtBinTree”类：

二叉链表可以有不带头结点（a）和带都结点（b）。

（a）带头指针的二叉链表（b）带头结点的二叉链表

privateBinTreeNoderoot;

//根结点

charcode[]=newchar[100];

intii=0;

//数组code的下标

public 

ExtBinTree 

（）：

构造函数：

建立只有一个根结点的二叉树。

（ExtBinTree 

bt1,ExtBinTree 

bt2 

）：

把两棵扩充二叉树合并成。

BinTreeNode 

GetRoot（） 

：

得到二叉树的根。

publicvoid 

SetRootData（intx,BinTreeNode 

left,BinTreeNode 

right）：

成员函数：

给根结点赋值。

int 

GetRootData（ 

） 

返回根结点数据域值。

void 

preOrderTraverse 

（BinTreeNode 

p）：

按前序递归遍历方式输出二叉树。

HuffmanCode（BinTreeNode 

p） 

输出扩充二叉树中隐含的霍夫曼编码。

//***********定义“扩充二叉树”类*********

classExtBinTree{

privateBinTreeNoderoot;

建立只有一个根结点的二叉树

publicExtBinTree（）{

root=newBinTreeNode（0）;

//结点值任意

把两棵扩充二叉树合并成

//一棵扩充二叉树。

根的数据域为两棵子

//树的数据域之和。

左右指针分别指向两棵子树。

publicExtBinTree（ExtBinTreebt1,ExtBinTreebt2）{

root=newBinTreeNode（bt1.GetRootData（）+

bt2.GetRootData（）,bt1.root,bt2.root）;

//得到二叉树的根

publicBinTreeNodeGetRoot（）{

returnroot;

//成员函数：

给根结点赋值

publicvoidSetRootData（intx,

BinTreeNodeleft,BinTreeNoderight）{

root.SetNode（x,left,right）;

//返回根结点数据域值

publicintGetRootData（）

{

returnroot.GetData（）;

//按前序递归遍历方式输出二叉树

//输出扩充二叉树中隐含的霍夫曼编码，

//用成员数组存放防止递归中对数组和下标反复初始化

charcode[]=newchar[100];

intii=0;

publicvoidHuffmanCode（BinTreeNodep）{

intj;

if（p!

if（p.leftChild==null&

&

p.rightChild==null）{

for（j=0;

j<

ii;

j++）

System.out.print（code[j]）;

System.out.println（）;

code[ii++]='

0'

;

HuffmanCode（p.leftChild）;

1'

HuffmanCode（p.rightChild）;

ii--;

//回溯前删除最后一个数组元素,，遇到空结点

}//****定义“扩充二叉树”类完毕

“MinHeap”类：

线性结构。

顺序存储结构。

privateExtBinTreeheap[];

//存放最小堆元素的数组

privateintCurrentSize;

//堆当前元素个数

privateintHeapMaxSize;

//堆元素个数上限

4.【主要成员方法说明】

private 

FilterDown 

（ 

start, 

EndOfHeap 

私有成员函数：

对以序号start为根结点的子树进行。

自顶向下的调整，使其成为最小堆。

参数EndOfHeap是子树里最后一个结点序号。

FilterUp 

start 

把堆中从 

到 

MinHeap 

arr[ 

], 

n 

构造函数，建立最小堆。

RemoveMin 

删除堆顶元素。

boolean 

Insert 

x 

向最小堆中插入一个元素。

IsEmpty 

判堆空否。

5.【高级语言代码】

//****定义“最小堆（元素类型为扩充二叉树）”

classMinHeap{

//私有成员函数：

对以序号start为根结点的子树进行

//自顶向下的调整，使其成为最小堆。

//参数EndOfHeap是子树里最后一个结点序号

privatevoidFilterDown（intstart,intEndOfHeap）{

inti=start;

intj=2*i+1;

//j是i的左孩子

ExtBinTreetemp=heap[i];

//暂存子树的根

while（j<

=EndOfHeap）{//调整完？

if（j<

EndOfHeap&

//比较树根结点的大小

heap[j].GetRootData（）>

heap[j+1].GetRootData（））

j++;

//让j指向左右孩子中最小者

if（temp.GetRootData（）<

=heap[j].GetRootData（））break;

//根结点不大于最小者，不调整

else{

heap[i]=heap[j];

//上浮调整

i=j;

//向下滑动一层

j=2*i+1;

//j是i的左孩子

heap[i]=temp;

//根结点归位

把堆中从start到0的元素

//自底向上进行调整成为最小堆

privatevoidFilterUp（intstart）{

intj=start;

inti=（j-1）/2;

//i是j的双亲

ExtBinTreetemp=heap[j];

//暂存起点元素

while（j>

0）{//调整到栈顶

if（heap[i].GetRootData（）<

=temp.GetRootData（））

break;

//不用调了

else{//向上调整

heap[j]=heap[i];

j=i;

i=（i-1）/2;

}

heap[j]=temp;

//起点元素归位

建立最小堆

publicMinHeap（ExtBinTreearr[],intn）{

HeapMaxSize=n*2;

//决定堆最大长度

heap=newExtBinTree[HeapMaxSize];

for（inti=0;

i<

n;

i++）

heap[i]=arr[i];

//堆元素来自数组

CurrentSize=n;

//当前堆大小

//找最初调整位置:

最后的非叶子结点号

intcurrentPos=CurrentSize/2-1;

//从下到上逐步扩大,最后形成完整的堆

while（currentPos>

=0）{

//对子树进行自顶向下调整，形成子堆。

FilterDown（currentPos,CurrentSize-1）;

//从currentPos开始,到数组末尾止,调整

currentPos--;

//删除堆顶元素

publicExtBinTreeRemoveMin（）{

if（IsEmpty（））returnnull;

ExtBinTreex=heap[0];

//最小元素出来

heap[0]=heap[CurrentSize-1];

CurrentSize--;

//用最大元素填补

FilterDown（0,CurrentSize-1）;

//调整

returnx;

//向最小堆插入一个元素

publicbooleanInsert（ExtBinTreex）{

if（CurrentSize==HeapMaxSize）//堆满

returnfalse;

heap[CurrentSize]=x;

//插在表尾

FilterUp（CurrentSize）;

//向上调整为堆

CurrentSize++;

//堆元素增一

returntrue;

//判堆空否

publicbooleanIsEmpty（）{

returnCurrentSize==0;

}//***定义“最小堆”结束

iData：

为结点的数据域，为int类型变量。

用于存放节点的数据。

next：

为节点的指针域，为link类型变量，存放结点的指向下一个节点的指针。

5.【主要成员方法说明】

link（double 

dD）：

为link类的构造函数。

该构造函数有一个数据域参数。

6.【高级语言代码】

//******“霍夫曼”树类

publicclassHuffmanTree{

//生成霍夫曼树（频率数组数组长度）

publicExtBinTreeMakeHuffmanTree（intfr[],intn）{

//定义两棵扩充二叉树

ExtBinTreefirst=newExtBinTree（）;

ExtBinTreesecond=newExtBinTree（）;

//定义一棵first和second的合并树

ExtBinTreenewtree=newExtBinTree（）;

//具有n棵扩充二叉树的森林，n为频率数组长度

ExtBinTreeNode[]=newExtBinTree[n];

//每棵扩充二叉树Node[i]只有一个带权值

//fr[i]的根结点,其左、右子树均为空。

for（inti=0;

i<

n;

i++）{

Node[i]=newExtBinTree（）;

//每一棵树初始化

Node[i].SetRootData（fr[i],null,null）;

}

//定义一个最小堆，数据类型为扩充二叉树

MinHeaphp=newMinHeap（Node,n）;

//重复n-1趟,逐步形成霍夫曼树

for（inti=0;

n-1;

first=hp.RemoveMin（）;

//把两个最小的元素从堆中删除

second=hp.RemoveMin（）;

//合并两个被删除的，得到新的扩充二叉树

newtree=newExtBinTree（first,second）;

//重新插入到最小堆中

hp.Insert（newtree）;

returnnewtree;

//主函数

publicstaticvoidmain（String[]args）{

//叶子结点的频率（权重）表

intf[]={2,7,4,5};

intn=4;

//叶子结点数目

//生成霍夫曼树：

扩充二叉树

HuffmanTreeH=newHuffmanTree（）;

ExtBinTreeh=H.MakeHuffmanTree（f,n）;

//前序遍历霍夫曼树

h.preOrderTraverse（h.GetRoot（））;

//输出霍夫曼编码

h.HuffmanCode（h.GetRoot（））;

}//******“霍夫曼”树类结束

（4）、程序的输入输出和运行结果截屏

运行结果如下图所示