北邮数据结构第三次实验-实验报告

数据结构实验报告

实验名称：实验三——栈和队列

学生姓名：

班级：

班内序号：

学号：

日期：

1.实验要求

1.1 实验目的

通过选择下面两个题目之一进行实现，掌握如下内容：

掌握二叉树基本操作的实现方法

了解赫夫曼树的思想和相关概念

学习使用二叉树解决实际问题的能力

1.2 实验内容

根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。

二叉树的基本功能：

1、二叉树的建立

2、前序遍历二叉树

3、中序遍历二叉树

4、后序遍历二叉树

5、按层序遍历二叉树

6、求二叉树的深度

7、求指定结点到根的路径

8、二叉树的销毁

9、其他：自定义操作

编写测试main()函数测试线性表的正确性

2. 程序分析

2.1 二叉链表

2.2 二叉树的二叉链表存储示意图

2.3 关键算法分析

2.3.1算法1：void create(Binode *&R, T data[], int i);

[1] 算法功能：创建一个二叉树

[2] 算法基本思想：通过构造函数创建一个二叉树，构造函数通过调用函数

create()创建二叉树，关于函数create()的伪代码：

1.定义根指针，输入节点储存的data，若输入“#”，则该节点为空；

2.申请一个新节点，判断它的父结点是否不为空，如果不为空在判断其为左

或者右孩子，并把地址付给父结点，把data写入。

[3] 算法空间、时间复杂度：O（n）

[4] 代码逻辑（可用伪代码描述）：if(data[i-1]!=0){R = new Binode;R->data

= data[i-1];R->lch = R->rch = NULL;create(R->lch, data,

2*i);create(R->rch, data, 2*i+1);}

2.3.2算法2：void Destroy(Binode *R);

[1] 算法功能：二叉树的销毁

[2] 算法基本思想：采用后序遍历的方法，释放节点。

[3] 算法空间、时间复杂度：O(n)

[4] 代码逻辑（可用伪代码描述）：

if(R!=NULL){Destroy(R->lch);Destroy(R->rch);

delete R;}

2.3.3算法3：void preorder(Binode *R);

[1] 算法功能：前序遍历二叉树

[2] 算法基本思想：设置递归边界条件：if root==null则停止递归；2打印起始

节点的值，并先后在左子数右子数上递归调用打印函数

[3] 算法空间、时间复杂度：O（n)

[4] 代码逻辑（可用伪代码描述）：

if(R!=NULL){cout<data;preorder(R->lch);preorder(R->rch);}

2.3.4算法4：void Inorder(Binode *R);

[1] 算法功能：中序遍历二叉树

[2] 算法基本思想： 1.设置递归边界条件：if root==null则停止递归，2.递归

遍历左子树3.打印根节点数据域内容4.递归遍历右子树

[3] 算法空间、时间复杂度：O（n)

[4] 代码逻辑（可用伪代码描述）：

if(R!=NULL){Inorder(R->lch);cout<data;

Inorder(R->rch);}

2.3.5算法5：void Postorder(Binode *R);

[1] 算法功能：后序遍历二叉树

[2] 算法基本思想：1.设置递归边界条件：if root==null则停止递归2.递归遍历

左子树3.递归遍历右子树4.访问根结点数据域

[3] 算法空间、时间复杂度：O（n)

[4] 代码逻辑（可用伪代码描述）：

if(R!=NULL){Postorder(R->lch);Postorder(R->rch);

cout<data;}}

2.3.6算法6：void Levelorder(Binode *R);

[1] 算法功能：层序遍历二叉树

[2] 算法基本思想：1.队列Q及所需指针的定义和初始化2.如果二叉树非空，将

根指针入队3.循环直到队列Q为空3.1 q=队列Q的队头元素出队3.2 访问

节点q的数据域cout<data<<" "; 3.3 若节点q存在左孩子，则将左孩

子指针入队 if (q->lchild != NULL) Q[rear++] = q->lchild; 3.4若

节点q存在右孩子，则将右孩子指针入队if (q->rchild != NULL)

[3] 算法空间、时间复杂度：O（n)

[4] 代码逻辑（可用伪代码描述）：Binode *queue[10000];int f = 0, r = 0;if(R!=NULL) queue[++r] = R;while(f!=r){Binode

*queue[++f];cout<data;if(p->lch!=NULL)

queue[++r] = p->lch;if(p->rch!=NULL)queue[++r] = p->rch;}

2.3.7算法7：int Depth(Binode *R, int d);

[1] 算法功能：计算二叉树深度

[2] 算法基本思想：1. 定义和初始化计数深度的参数2．如果根节点为空，return0

3．如果根节点为非空，递归调用自身的到叶子节点到根的路径长度，输出其中

较大的作为树的深度

[3] 算法空间、时间复杂度：O（n)

[4] 代码逻辑（可用伪代码描述）：if(R==NULL) return d;

if((R->lch==NULL)&&(R->rch==NULL))return d+1;else{int m =

Depth(R->lch, d+1);int n = Depth(R->rch, d+1);return n>m?n:m;}

2.3.8算法8：void path(Binode *root, char m);

[1] 算法功能：输出指定结点到根结点的路径

[2] 算法基本思想：代码：1.建立一个存储路径结点结构，定义和初始化结构体的数

组2.当root不为空或top为0时，进入循环3.当此时root所指的节点的数据

不为指定数据时，将root指向它的左孩子4.当此时root所指的节点的数据为

指定数据时，访问其数据域并输出

[3] 算法空间、时间复杂度：O(n)

[4] 代码逻辑（可用伪代码描述）：Binode *stack[10000];Binode *s;int

tag[10000];

int top = 0;s =

root;do{while(s!=NULL){top++;stack[top]=s;tag[top]=0;s=s->lch;}

if(top>0){if(tag[top] == 1){if(stack[top]->data == m){cout<<"路径：

\t";for(int

i=1;i<=top;i++)cout<data;break;}top--;}else{s=stack[top]

;if(top>0){s=s->rch;tag[top]=1;}}}}while(s!=NULL || top!=0);}

3.程序运行结果

4.总结

1．本次实验内容相对基础，很多代码在书上都能找到，但是写程序的时候还是遇到了一些问题特别是在参数传递方面很容易出错，因为本次实验的很多算法都依靠递归来实现，递归具有代码简洁但理解不易的特点，特别是在参数传递方面，要通过作图等方式才能搞清楚整个递归过程。

2. 由于单单靠前序、中序、后者序都无法唯一确定的建立一个二叉树，所以课本上提供的算法是输入按一定规则补全后的二叉树，首先应该明白输入的规则，要不然程序运行也很容易出错。

3. 本程序多了两个计算结点的函数，本来最开始想编一个打印树的函数，可是发现定位光标的位置实在非常有难度，而且采用本程序的存储结构好像很难实现，只好作罢，但是还是很希望能有机会编出来。

4. 开始的时候也是写了按前序遍历创树的，用了简单的递归调用，但是发现输入会有许多不便。所以很希望可以按层输入，于是做了尝试，虽然代码可能写的不是很简单，但是终于实现了按层输入。在c++语言的编写中就应该使其有更好的实用性，并敢于尝试，不断改进。

附源代码：

#include

using namespace std;

template struct Binode//节点结构

{

T data; //数据

Binode *lch; //左孩子

Binode *rch; //右孩子

};

template class Bitree//二叉树类

{

private:

void create(Binode *&R, T data[], int i);

void Destroy(Binode *R);

public:

Binode *root;

Bitree(T data[]);

Bitree(){};

void preorder(Binode *R);

void Inorder(Binode *R);

void Postorder(Binode *R);

void Levelorder(Binode *R);

int Depth(Binode *R, int d);

void path(Binode *root, char m);

~Bitree();

};

template

void Bitree::create(Binode *&R, T data[], int i)//创建二叉树{

if(data[i-1]!=0)

{

R = new Binode;

R->data = data[i-1];

R->lch = R->rch = NULL;

create(R->lch, data, 2*i);

create(R->rch, data, 2*i+1);

}

}

template

Bitree::Bitree(T data[])//创建根节点

{

create(root, data, 1);

}

template

void Bitree::preorder(Binode *R)//前序遍历二叉树{

if(R!=NULL)

{

cout<data<<" ";

preorder(R->lch);

preorder(R->rch);

}

}

template

void Bitree::Inorder(Binode *R)//中序遍历二叉树{

if(R!=NULL)

{

Inorder(R->lch);

cout<data<<" ";

Inorder(R->rch);

}

}

template

void Bitree::Postorder(Binode *R)//后序遍历二叉树{

if(R!=NULL)

{

Postorder(R->lch);

Postorder(R->rch);

cout<data<<" ";

}

}

template

void Bitree::Levelorder(Binode *R)//层序遍历二叉树{

Binode *queue[10000];

int f = 0, r = 0;

if(R!=NULL)

queue[++r] = R;

while(f!=r)

{

Binode *p = queue[++f];

cout<data<<" ";

if(p->lch!=NULL)

queue[++r] = p->lch;

if(p->rch!=NULL)

queue[++r] = p->rch;

}

}

template

void Bitree::Destroy(Binode *R)//销毁二叉树

{

if(R!=NULL)

{

Destroy(R->lch);

Destroy(R->rch);

delete R;

}

}

template

Bitree::~Bitree()//析构函数，销毁根节点，释放内存{

Destroy(root);

}

template

int Bitree::Depth(Binode *R, int d)//求深度

{

if(R==NULL)

return d;

if((R->lch==NULL)&&(R->rch==NULL))

return d+1;

else

{

int m = Depth(R->lch, d+1);

int n = Depth(R->rch, d+1);

return n>m?n:m; //选择最大深度返回}

}

template

void Bitree::path(Binode *root, char m)//求路径

{

Binode *stack[10000];//定义栈

Binode *s;

int tag[10000]; //标志数组

int top = 0;

s = root;

do

{

while(s!=NULL) //只要指针不为空，把s和s的左孩子写入stack[]

{

top++;

stack[top]=s; //储存标记查找目标时走过的路径

tag[top]=0; //tag[top]=0表示第top个结点为左孩子

s=s->lch;

}

if(top>0) //栈不为空

{

if(tag[top] == 1)

{

if(stack[top]->data == m) //找到目标，输出路径

{

cout<<"路径：\t";

for(int i=1;i<=top;i++)

cout<data<<" ";

break;

}

top--; //没找到目标，删除该结点，把结点上移

}

else

{

s=stack[top];

if(top>0)

{

s=s->rch; //最后一个结点无左孩子，开始向右查找目标

tag[top]=1; //tag[top]=1表示第top个结点为右孩子

}

}

}

}while(s!=NULL||top!=0);//找到目标或者查找整棵树没有发现目标时退出循环}

int main()

{

cout<<"请输入二叉树中的元素"<

char buf[400] = {0}, i = 0;

char c;

do {

cin>>buf[i++];

}while ((c = getchar()) != '\n');

Bitree test(buf);

int w= 100;

while (w != 0)

{

cout << "--------------------菜单选项----------------------\n"; cout << "******** 1、前序遍历******************************\n"; cout << "******** 2、中序遍历******************************\n"; cout << "******** 3、后序遍历******************************\n"; cout << "******** 4、层序遍历******************************\n"; cout << "******** 5、二叉树深度****************************\n"; cout << "******** 6、路径**********************************\n"; cout << "******** 0、退出菜单*****************************\n"; cout << "--------------------------------------------------\n"; cout << "请输入你要选择的菜单选项:" << endl;

cin >> w;

switch (w)

{

case 1:

cout<<"前序遍历：\t";

test.preorder(test.root);

cout<

break;

case 2:

cout<<"中序遍历：\t";

test.Inorder(test.root);

cout<

break;

case 3:

cout<<"后序遍历：\t";

test.Postorder(test.root);

cout<

break;

case 4:

cout<<"层序遍历：\t";

test.Levelorder(test.root);

cout<

break;

case 5:

cout<<"二叉树深度为：\t"<

break;

case 6:

cout<<"请输入节点位置"<

int j;

cin>>j;

test.path(test.root, buf[j-1]);

cout<

break;

case 0:

break;

default:

cout << "没有该菜单选项,请重新选择\n";

break;

}

}

}