山东大学数据结构实验报告六汇编.docx
《山东大学数据结构实验报告六汇编.docx》由会员分享，可在线阅读，更多相关《山东大学数据结构实验报告六汇编.docx（18页珍藏版）》请在冰豆网上搜索。
山东大学数据结构实验报告六汇编
数据结构实验报告——实验六
实验题目：
排序算法
学号：
201411130001
日期：
2015.12.11
班级：
计机14.1
姓名：
刘方铮
Email：
liu191150932@
实验目的：
堆和搜索树
任务要求：
一、实验目的
1、掌握堆和搜索树的基本概念，插入、删除方法。
二、实验内容
创建最大堆类。
最大堆的存储结构使用链表。
提供操作:
堆的插入、堆的删除。
堆的初始化。
Huffman树的构造。
二叉搜索树的构造。
接收键盘录入的一系列整数，输出其对应的最大堆、Huffman编码以及二叉搜索树。
堆排序。
软件环境：
Win7操作系统
开发工具：
visualC++6.0
实验代码：
#include
#include
#include
#include
usingnamespacestd;
classBinaryTreeNode
{
public:
BinaryTreeNode（）{LeftChild=RightChild=0;}
BinaryTreeNode（constint&e）
{
data=e;
LeftChild=RightChild=0;
}
BinaryTreeNode（constint&e,BinaryTreeNode*l,BinaryTreeNode*r）
{
data=e;
LeftChild=l;
RightChild=r;
}
intdata;
BinaryTreeNode*LeftChild,*RightChild;
};
voidTravel（BinaryTreeNode*roots）{
queueq;
while（roots）{
cout<data<<"";
if（roots->LeftChild）q.push（roots->LeftChild）;
if（roots->RightChild）q.push（roots->RightChild）;
try{
roots=q.front（）;
q.pop（）;
}
catch（...）
{return;}
}
}
voidPrOrder（BinaryTreeNode*roots）{
if（roots）{
cout<data<<" ";
PrOrder（roots->LeftChild）;
PrOrder（roots->RightChild）;}
}
voidInOrder（BinaryTreeNode*roots）{
if（roots）{
InOrder（roots->LeftChild）;
cout<data<<"";
InOrder（roots->RightChild）;}
}
classMaxHeap{
public:
MaxHeap（）{
root=0;
state=0;
}
voidMakeHeap（intelement,MaxHeap&left,MaxHeap&right）;
intMax（）{
if（!
root）
return0;
returnroot->data;
}
MaxHeap&Insert（constint&x）;
MaxHeap&DeleteMax（int&x）;
MaxHeap&Initialize（inta[],intn）;
voidDeactivate（）{heap=0;}
voidHeapSort（inta[],intn）;
BinaryTreeNode*root,*last,*p_last;
intstate;
voidConditionOrder（BinaryTreeNode*u,intk,inti,BinaryTreeNode*temp）;
voidAdjust（BinaryTreeNode*u）;
BinaryTreeNode*LocateLast（BinaryTreeNode*u,intk,inti）;
private:
MaxHeap*heap;
};
voidMaxHeap:
:
MakeHeap（intelement,MaxHeap&left,MaxHeap&right）
{
root=newBinaryTreeNode（element,left.root,right.root）;
left.root=right.root=0;
last=p_last=root;
state++;
}
BinaryTreeNode*MaxHeap:
:
LocateLast（BinaryTreeNode*u,intk,inti）
{
if（k<=1）
returnu;
else
{
intn=（int）pow（2.0,k-1）;
ints=n/2;
if（i<=s）
returnLocateLast（u->LeftChild,k-1,i）;
else
returnLocateLast（u->RightChild,k-1,i-s）;
}
}
voidMaxHeap:
:
ConditionOrder（BinaryTreeNode*u,intk,inti,BinaryTreeNode*temp）
{
inthalf=（int）pow（2.0,k-2）;
if（u->datadata）
{
swap（u->data,temp->data）;
}
if（!
u->LeftChild||!
u->RightChild）
{
if（!
u->LeftChild）
{
u->LeftChild=temp;
p_last=u;
state++;
}
else{
u->RightChild=temp;
p_last=u;
state++;
}
}
else
{
if（i<=half）
ConditionOrder（u->LeftChild,k-1,i,temp）;
else
ConditionOrder（u->RightChild,k-1,i-half,temp）;
}
}
MaxHeap&MaxHeap:
:
Insert（constint&x）{
if（root）{
intk=（int）（log（（double）（state））/log（2.0））+1;
intindex=state-（int）（pow（2.0,k-1）-1）;
intp_index=index/2+1;
BinaryTreeNode*temp=newBinaryTreeNode（x）;
last=temp;
if（index==（int）（pow（2.0,k-1）））{
p_index=1;
ConditionOrder（root,k,p_index,temp）;
}
else
ConditionOrder（root,k-1,p_index,temp）;}
else{
root=newBinaryTreeNode（x）;
last=p_last=root;
state++;}
return*this;
}
voidMaxHeap:
:
Adjust（BinaryTreeNode*u）{
if（!
u->LeftChild&&!
u->RightChild）
return;
elseif（u->LeftChild&&u->RightChild）{
if（u->LeftChild->data>u->RightChild->data）{
if（u->dataLeftChild->data）
{
swap（u->data,u->LeftChild->data）;
Adjust（u->LeftChild）;
}
}
else
{
if（u->dataRightChild->data）
{
swap（u->data,u->RightChild->data）;
Adjust（u->RightChild）;
}
}
}}
MaxHeap&MaxHeap:
:
DeleteMax（int&x）
{
if（!
root）
exit
（1）;
elseif（!
last）
{x=root->data;
state=0;root=0;}
else{
x=root->data;
root->data=last->data;
intk=（int）（log（（double）（state））/log（（double）
（2）））+1;
intindex=state-（int）（pow（2.0,k-1）-1）;
Adjust（root）;
if（index%2）
p_last->LeftChild=0;
else
p_last->RightChild=0;
deletelast;
state--;
k=（int）（log（（double）（state-1））/log（（double）
（2）））+1;
index=state-1-（int）（pow（2.0,k-1）-1）;
intp_index=index/2+1;
if（index==（int）（pow（2.0,k-1）））{
p_index=1;
p_last=LocateLast（root,k,p_index）;
}
else
p_last=LocateLast（root,k-1,p_index）;
if（!
p_last->RightChild）
last=p_last->LeftChild;
else
last=p_last->RightChild;}
return*this;
}
MaxHeap&MaxHeap:
:
Initialize（inta[],intn）
{
MaxHeapLMaxHeap,RMaxHeap;
MakeHeap（a[0],LMaxHeap,RMaxHeap）;
for（inti=1;iInsert（a[i]）;
return*this;
}
voidMaxHeap:
:
HeapSort（int*a,intn）
{
//创建一个最大堆
MaxHeapmaxHeap;
maxHeap.Initialize（a,n）;
//从最大堆中逐个抽取元素
intx;
for（inti=n-1;i>=0;i--）
{
maxHeap.DeleteMax（x）;
//cout<<"i="<//Travel（root）;cout<a[i]=x;
}
//在堆的析构函数中保存数组a
//maxHeap.Deactivate（）;
}
classHTNode
{
public:
intweight;//权重
intparent,lchild,rchild;
};
typedefHTNode*HuffmanTree;
HuffmanTreeHuffmanCoding（char**&HC,intw[],inta[],intn）;
voidSelect（HuffmanTreeHT,intn,int&s1,int&s2）;
voidHTEcode（char**&HC,intw[],intcode[],intcodeLen,inta[],intaLen）;
voidSelect（HuffmanTreeHT,intn,int&s1,int&s2）
{
inti=1,j;
while（HT[i].parent!
=0）
i++;
j=i+1;
while（HT[j].parent!
=0）
j++;
if（HT[i].weight>HT[j].weight）
{
s1=j;//s1为权重小的
s2=i;
}
else
{
s1=i;
s2=j;
}
i=j+1;
while（i<=n）
{
if（HT[i].parent!
=0）
i++;
elseif（HT[i].weight{
s2=s1;
s1=i;
}
elseif（HT[i].weights2=i;
i++;
}
}
HuffmanTreeHuffmanCoding（char**&HC,intw[],inta[],intn）
{
inti,start,c,f;
HTNode*p;
char*cd;
if（n<1）returnNULL;
intm=2*n-1;
//定义一个有m+1个节点的霍夫曼树
HuffmanTreeHT=newHTNode[m+1];
//初始化
for（p=HT+1,i=1;i<=n;i++,p++）
{
p->weight=w[i-1];
p->lchild=0;
p->rchild=0;
p->parent=0;
}
ints1,s2;
for（;i<=m;++i）
{
Select（HT,i-1,s1,s2）;
HT[s1].parent=i;
HT[s2].parent=i;
HT[i].parent=0;
HT[i].lchild=s1;
HT[i].rchild=s2;
HT[i].weight=HT[s1].weight+HT[s2].weight;
}
HC=newchar*[n];
cd=newchar[n];
cd[n-1]='\0';
for（i=1;i<=n;++i）
{
start=n-1;
for（c=i,f=HT[i].parent;f!
=0;c=f,f=HT[f].parent）
{
if（HT[f].lchild==c）
cd[--start]='0';
else
cd[--start]='1';
}
HC[i-1]=newchar[n-start];
strcpy（HC[i-1],&cd[start]）;
}
returnHT;
}
voidHTEcode（char**&HC,intw[],intcode[],intcodeLen,inta[],intaLen）
{intj;
HuffmanTreeHT=HuffmanCoding（HC,w,code,codeLen）;
//for（intf=1;f<=2*codeLen-1;f++）
//cout<<"\n序号:
"<"<"<"<"<for（intr=0;r{
cout<<"\n"<"<}
for（inti=0;i{boolfind=false;
for（j=0;j{
if（a[i]==code[j]）
{
find=true;
cout<}
}
//if（!
find）
//cout<<"空";
}
}
classDBSTree{
public:
DBSTree（）{root=0;};
BinaryTreeNode*root;
DBSTree&BSInitialize（inta[],intlen）;
DBSTree&BSInsert（constint&e）;
};
DBSTree&DBSTree:
:
BSInsert（constint&e）{
BinaryTreeNode*p=root,*pp=0;
while（p）{
pp=p;
if（edata）
p=p->LeftChild;
elseif（e>p->data）
p=p->RightChild;
}
BinaryTreeNode*r=newBinaryTreeNode（e）;
if（root）{
if（edata）
pp->LeftChild=r;
elsepp->RightChild=r;}
else
root=r;
return*this;
}
DBSTree&DBSTree:
:
BSInitialize（inta[],intlen）{
for（inti=0;iBSInsert（a[i]）;
return*this;
}
voidmain（）
{MaxHeapmaxHeap;
DBSTreebstree;
ints,n,sel,Alen;
char**codeA;
int*IntA,*w;
cout<<"输入最大堆元素个数";
intlen;
cin>>len;
int*a=newint[len];
for（inti=0;icout<<"输入第"<cin>>a[i];
}
maxHeap.Initialize（a,len）;
cout<<"最大堆操作:
"<cout<<"0.堆排序"<maxHeap.HeapSort（a,len）;
for（inth=0;hcout<cout<cout<<"1.初始化层次遍历输出最大堆"<Travel（maxHeap.root）;
cout<cout<<"前序遍历输出最大堆\n";
PrOrder（maxHeap.root）;
cout<cout<<"2.插入整数元素"<cin>>s;
maxHeap.Insert（s）;
cout<<"层次遍历输出最大堆\n";
Travel（maxHeap.root）;
cout<cout<<"前序遍历输出最大堆\n";
PrOrder（maxHeap.root）;
cout<cout<<"3.删除最大元素\n";
maxHeap.DeleteMax（s）;
cout<<"层次遍历输出最大堆\n";
Travel（maxHeap.root）;
cout<///////////////////////////////////////
cout<<"Huffman操作";
cout<<"输入元素个数"<cin>>Alen;
IntA=newint[Alen];
w=newint[Alen];
for（n=0;ncout<<"\n输入第"<cin>>IntA[n];
cout<<"\n输入对应权值\n";
cin>>w[n];
}
HuffmanCoding（codeA,w,IntA,len）;
HTEcode（codeA,w,IntA,Alen,a,len）;
cout<///////////////////////////////////////////
cout<<"二叉搜索树层次遍历"<cout<<"输入二叉搜索树元素个数";
intbslen;
cin>>bslen;
int*b=newint[bslen];
for（intj=0;jcout<<"输入第"<cin>>b[j];
}
bstree.BSInitialize（b,bslen）;
cout<<"前序遍历输出二叉搜索树:
"<PrOrder（bstree.root）;
cout<cout<<"中序遍历输出二叉搜索树:
"<InOrder（bstree.root）;
cout<cout<<"层次遍历输出二叉搜索树:
"<Travel（bstree.root）;
cout<}
实验结果：
升级会员 