数据结构实验——分类二叉树和堆排序

数据结构《实验3》实验报告

附源程序

#include

#include

#define MaxSize 10

typedef struct

{

int Num;

float score1;

float score2;

float score3;

}Student;//储存学生信息，依次为学号，语文成绩，数学成绩，英语成绩typedef struct

{

float total;//学生总分

Student * p;

}HeapNode;

//

typedef struct BinaryTreeNode

{

HeapNode data;

BinaryTreeNode * LChild;

BinaryTreeNode * RChild;

}BinaryTreeNode;

//分类二叉树的结点

int HeapSize=9;

void Displayarray(HeapNode a[])//输出堆排序的结果

{

int i;

for(i=1;i<10;i++)

printf(" 学号%d 总分%f\n",a[i].p->Num,a[i].total);

printf("\n");

}

void Menu_name()

//作者信息

{

printf("\n\n\n\n\n\n\n");

printf("

*************************************************\n");

printf(" 堆排序和分类二叉树的查找\n\n");

printf(" 制作: \n 学号0909050108\n");

printf(" 班级: \n");

printf(" 指导老师: \n");

printf("

**************************************************\n");

printf("\n\n\n\t\t");

}

void MaxHeapInit (HeapNode a[], int size)

{// 对数组a 中的数据初始化为一个最大堆

HeapNode *heap=a; //数组a用Heap指向

HeapSize=size; //数组中数据元素个数存放到HeapSize for (int i = HeapSize/2; i >= 1; i--) //从最后一个结点的根开始，直到第一个结点

{

heap[0] = heap[i]; // 将子树根结点值复制到工作空间heap[0]中

int son = 2*i; // son的双亲结点是heap[0]的目标位

置，

// son首先指向i的左孩子

while (son <= HeapSize)

{// 找左右孩子中较大结点

if (son < HeapSize && heap[son].total < heap[son +1].total)

son ++;

// son < HeapSize时，存在右孩子，如左孩子小于右孩子，son指向右孩子

if (heap[0].total>= heap[son].total) // 大孩子再与工作空间中结点值再比较

break; //工作空间中值大，找到heap[0]的目标位置

heap[son /2] = heap[son]; // 将大孩子上移至双亲位置

son*= 2; // son下移一层到上移的结点（大孩子）位置

}

heap[son /2] = heap[0]; //heap[0]存放到目标位置}

}

//最大堆中删除顶结点，并放入x中返回算法

bool MaxHeapDelete (HeapNode a[], HeapNode &x)

{

HeapNode *heap = a;

if (HeapSize == 0)

return false; // 堆空

x = heap[1]; // 最大结点存放到x

heap[0] = heap[HeapSize--]; // 最后一个结点存放到heap[0]，调整堆中元素的个数

int i = 1, son = 2*i;

while (son <= HeapSize)

{

if (son < HeapSize && heap[son] .total< heap[son+1].total)

son++;

if (heap[0].total >= heap[son].total)

break;

heap[i] = heap[son]; // 孩子上移

i = son; // 下移根结点指针，继续比较

son = son * 2;

}

heap[i] = heap[0];

return true;

}

void HeapSort(HeapNode a[], int n)

{// 利用堆对a[1:n] 数组中的数据排序

HeapNode *heap=a;

MaxHeapInit(heap, n); // Heap初始化为最大堆

HeapNode x;

int m=1;

for (int i = n-1; i >= 1; i--)

{

MaxHeapDelete (heap,x);

printf(" 第%d堆排序结果\n",m);

m++;

Displayarray(a);

system("pause");

system("cls");

heap[i+1] = x;

}

}

BinaryTreeNode *SortBinaryTreeInsert (BinaryTreeNode *&BT, HeapNode &x) {//求如果不重复出现，则插入结点x

BinaryTreeNode *p;

BinaryTreeNode *parent = NULL; //指向p的双亲

p=BT;

while (p)

{

parent = p;

if (x.total < p->data.total)

p=p->LChild;

else

if (x.total > p->data.total)

p = p->RChild;

else

return p; //重复出现，即相等值结点出现

}

// 找到插入点，为x申请一个空间填入其值，并将该结点连接至parent BinaryTreeNode *q = new BinaryTreeNode;

q ->data = x;

q->LChild=NULL;

q->RChild=NULL;

if (BT)

{// 原树非空

if (x.total < parent ->data.total)

parent ->LChild = q;

else

parent ->RChild = q;

}

else // 插入到空树中

BT = q;

return BT;

}

int SortBinaryTreeSearch (BinaryTreeNode *BT, HeapNode &x, float &SearchKey)

{//求查找关键字为SearchKey的结点值x

BinaryTreeNode *p = BT;

while (p)

if (SearchKeydata.total)

p = p->LChild;

else

if (SearchKey>p->data.total)

p = p->RChild;

else

{

x = p->data;

return 1;

}

return 0;

}

void main()

{

HeapNode a[10];

Student student[10];

HeapNode x;

float key;

Student *p;

BinaryTreeNode *BT;

int re;

int m=20010000;

Menu_name();

for(int i=0;i<=10;i++)

{

student[i].Num=i;

a[i].p=&student[i];

}

student[0].score1=0;

student[0].score2=0;

student[0].score3=0;

student[1].score1=85;

student[1].score2=88;

student[1].score3=97;

student[2].score1=92.5;

student[2].score2=91;

student[2].score3=95;

student[3].score1=95;

student[3].score2=98;

student[3].score3=99;

student[4].score1=85;

student[4].score2=87;

student[4].score3=96.5;

student[5].score1=96;

student[5].score2=93;

student[5].score3=100;

student[6].score1=72;

student[6].score2=76;

student[6].score3=70.5;

student[7].score1=65;

student[7].score2=53;

student[7].score3=53;

student[8].score1=88;

student[8].score2=94;

student[8].score3=90.5;

student[9].score1=96.5;

student[9].score2=83;

student[9].score3=65;//输入学生信息printf(" 堆排序操作\n\n");

for( i=0;i<=10;i++)

{

student[i].Num=m;

a[i].p=&student[i];

a[i].total=student[i].score1+student[i].score2+student[i].score3;

m++;

}//构造堆树

printf(" 未排序前的堆结点信息\n");

Displayarray(a);

system("pause");

system("cls");

int keep=HeapSize;

HeapSort(a,HeapSize);

printf("\n 堆排序结果:\n");

Displayarray(a);

printf("\n");

system("pause");

BT=NULL;

printf(" 分类二叉树的操作\n");

for(i=1;i<10;i++)

{

SortBinaryTreeInsert(BT,a[i]);//构造分类二叉树

}

for(;;)

{

printf(" 请输入您要查找的学生的总分,输入0结束查找");

scanf("%f",&key);

if(key)

{

re=SortBinaryTreeSearch(BT,x,key);

if(re)

{

p=x.p;

printf(" 学号%d\n语文成绩%f\n英语成绩%f\n数学成绩%f\n",p->Num,p->score1,p->score2,p->score3);

}

else

printf(" 没有找到要查找的学生信息\n");

}

else

exit(0);

}

}