哈工大数据结构实验二——二叉树的建立、遍历及其应用

最新推荐文章于 2023-04-26 19:51:17 发布
最新推荐文章于 2023-04-26 19:51:17 发布
阅读量2.7k 收藏 48
点赞数 15
分类专栏： 数据结构 文章标签： 二叉树 数据结构 二叉树的遍历 二叉树的建立 哈工大数据结构实验二
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45406155/article/details/109186258
版权

目录

其他类似的博客

哈工大数据结构实验二——哈夫曼编码与译码方法
哈工大2019秋数据结构期末试题
哈工大数据结构实验一算术表达式求值
哈工大数据结构实验一 线性结构及其应用

0.实验要求

在这里插入图片描述

1.二叉树的存储

二叉树的存储相信不用多讲啥，直接使用最常见的动态二叉链结构存储即可。

typedef struct  BTnode *Tnode; //使用链式结构表示二叉树，
struct BTnode{//声明一个树的节点，
	    //它包含这个节点的数据以及指向左儿子和右儿子的指针 
 	char data;//节点存储的字符
 	Tnode lchild,rchild;  //指向左右儿子的指针  
} ;

2.递归创建二叉树

递归创建二叉树，我直接先序递归创建二叉树。和先序遍历思想几乎一样。先创建根节点，然后先序递归的创建左子树，然后先序递归的创建右子树。

我用’#'表示一个空节点

void PreCreatTree(Tnode *T){ //先序创建一个二叉树 
 	char x;
	 cin>>x;
	 if(x=='#'){//'#'表示空节点 
 	     *T=NULL;
	 } 
 	else{
	     *T=new BTnode;//给节点分配存储空间 
 	 if(!*T){
   	    cout<<"error"<<endl;
  	}
 	 else{
  	 //先序递归创建二叉树 
 	    (*T)->data =x;//创建根节点
  	    PreCreatTree(&(*T)->lchild );//先序递归的创建左子树
 	    PreCreatTree(&(*T)->rchild );//先序递归的创建右子树
  	     }     
        }
}

3.非递归创建二叉树

怎么非递归的创建二叉树呢？我们可以用数组来存储一个二叉树，从数组下标1的位置存储根节点。数组的下标就隐含描述了节点的父子关系。

  • 我们考虑两个节点，他们存储在数组中的下标分别为i , j ,不失一般性，设i < j
  • 如果 j = 2 * i ,那么j 是 i 的左儿子
  • 如果 j = 2 * i + 1 ,那么 j 是i 的右儿子

那么我们的思路就明了了，每次只要给出这个节点存储的下标，那么根据上述的关系式，我们可以知道这个节点的父节点下标，也能知道这个节点是父节点的左儿子还是右儿子，然后让根节点指向这个儿子节点即可。

Tnode s1[100];     //用来创建递归树所用的数组 
Tnode CreatTree(){    //非递归创建二叉树 
 	int i,j;
 	char c;
 	Tnode bt,p;//用于存放节点
 
 	cin>>i>>c;//给定存储某个字符的数组下标和该字符来创建二叉树
 	while(i!=0&&c!='#') {
 	     p=new BTnode;
 	     p->data =c;
  	     p->lchild =NULL;     
             p->rchild =NULL;
 	     s1[i]=p;
	     if(i==1) bt=p;//根节点
	     else if(i==2) bt->lchild =p;
  	     else{
 		   j=i/2;//父节点
  	          if(i%2==0) {//这个节点是父节点的左儿子
  	               s1[j]->lchild=p;
  		    }
  		  if(i%2!=0)//这个节点是父节点的右儿子   
  		  	s1[j]->rchild=p;
  } 
  	cin>>i>>c;
 }
	 return bt;
}

通过读取文件非递归创建二叉树

Tnode DuRuTree(){    //非递归创建二叉树 
 	fstream in;
	 in.open("erchashu.txt"); 
 	 int i,j;
	 char c;
	 Tnode bt,p;//用于存放节点
	 in>>i>>c;
	 while(i!=0&&c!='#') {
 	 	p=new BTnode;
 		p->data =c;
	        p->lchild =NULL;
	        p->rchild =NULL;
	        s1[i]=p;
 	       if(i==1) bt=p;
	       else if(i==2) bt->lchild =p;
 	       else{
 	           j=i/2;
 	           if(i%2==0){
 	           	s1[j]->lchild=p;
  	             }
 	  	if(i%2!=0)   s1[j]->rchild=p;
 	        } 
 	       in>>i>>c;
	 }
	 in.close() ;
	 return bt;
}

在这里插入图片描述
在这里插入图片描述

4.二叉树的遍历

4.1先序递归遍历二叉树

太简单了，不阐述了

void PreOrder(Tnode T){   //先序递归遍历二叉树 
 	if(T==NULL){
  	    return ;
	 }
  	cout<<T->data<<" ";
 	PreOrder(T->lchild );
 	PreOrder(T->rchild );
}

4.2非递归先序遍历二叉树

非递归先序遍历我们需要借助栈来完成，我们对先序的理解就是一直往左儿子走，沿途输出遇到的所有左儿子，直到走到最左的儿子，然后我们再去先序遍历这个左儿子的兄弟

那么问题来了，你走到了最左儿子，怎么找到左儿子的兄弟呢？由于节点不存储指向兄弟的指针，因此，你必须通过父节点去找右儿子。

现在的问题就是你怎么去找父节点呢？由于节点不存储指向父亲的指针，因此你必须把父节点保留起来。没错，就是用栈。

栈有个特性：后进先出，先进后出，也就是说栈中相邻的两个节点就是父子关系。所以当我们碰到最左节点后，栈顶的那个节点就是我们这个最左节点的父亲，只要把这个节点弹出来，然后我们就可以去继续遍历父节点的右儿子啦。(这个时候不需要输出父节点，因为父节点在进栈的时候已经输出了)

void fPreOrder(Tnode root){  //非递归先序遍历二叉树 
	 if(root==NULL){
 	     return;
 	 }
 	Tnode p=root;
 	stack<Tnode>s;
	 while(!s.empty()||p){
	     while(p){ //一直往左走 ， 先序遍历
   		cout<<p->data<<' ' ;
   		s.push(p);
   		p=p->lchild ; 
  	      }
  	 //已经走到最左儿子
  	if(!s.empty() ){
        	p=s.top() ;//弹出父节点
        	s.pop() ;
       		 p=p->rchild ;	//然后去父节点的右儿子先序遍历
       }
  }
}

4.3非递归中序遍历二叉树

非递归中序遍历和非递归先序遍历原理一样，只是输出节点的时间不同，先序遍历是把节点压栈的时候就输出节点，非递归中序遍历是把节点从栈中弹出的时候输出节点。

void fInOrder(Tnode root){  //非递归中序遍历二叉树 
	 if(root==NULL)
   		return ;
	 Tnode p=root;
	 stack<Tnode>s;
	 while(!s.empty()||p){
	       while(p){
  	       s.push(p);
   		p=p->lchild ;
 	 }
	  if(!s.empty()){
	     p=s.top();
 	     s.pop();
 	     cout<<p->data<<' ' ;
  	     p=p->rchild ;
	}
	}
}

4.4递归中序遍历二叉树

void InOrder(Tnode T){
 	if(T==NULL){
 	     return ;
	  }
	 InOrder(T->lchild );
	 cout<<T->data<<" ";  
 	 InOrder(T->rchild );
}

4.5非递归后序遍历二叉树

二叉树的后序遍历是遍历中最难的，但是跟着我，你绝对能懂。
二叉树的后序遍历的难点无非在于何时输出节点。
使用一个变量plastvisit记录上一次访问的节点，这个辅助节点有什么用处？

  1. 我们使用plastvisit变量跟踪上一次访问的节点。假设栈顶元素是pcur。当plastvisit是pcur的父节点时，我们正在向下遍历树。此时，优先遍历curr的左孩子（将左孩子压入栈）。如果没有左孩子，再看右孩子。如果左右孩子都不存在（pcur是叶节点），就输出curr的值并弹出栈顶元素。
  2. 如果plastvisit是pcur的左孩子，我们正在从左子树向上遍历。我们看一下pcur的右孩子。如果可以，就从右孩子向下遍历（将右孩子压入栈），否则打印pcur的值并弹出栈顶元素。
  3. 如果plastvisit是pcur的右孩子，我们正在从右子树向上遍历。打印curr的值并弹出栈顶元素。
void fPostOrder(Tnode root){ //非递归后序遍历二叉树 
 	if(root==NULL){
	     return;
	 }
	 stack<Tnode>s;
	 Tnode pcur,plastvisit;//pcur是当前节点，plastxisit是上次访问的节点 
	 pcur=root;
	 plastvisit=NULL;
	 while(pcur){
	    s.push(pcur);
 	    pcur=pcur->lchild ;
	 }
 	 while(!s.empty() ){
 	     pcur=s.top() ;
 	     s.pop() ;
   	    if(pcur->rchild ==NULL||pcur->rchild ==plastvisit){
   		 cout<<pcur->data<<' ' ;
    		plastvisit=pcur;
   		}
  	    else{
            s.push(pcur);
            pcur=pcur->rchild ;
            while(pcur){
   	 	 s.push(pcur);
   	  	pcur=pcur->lchild ; 
		}
	   }
	}
}

4.6层序遍历二叉树

层序遍历很简单，我们需要借助队列

  1. 一开始，我们把根节点压入队列中
  2. 循环直到队列为空
    ①把队列首节点p弹出并且输出
    ②把p的左右儿子依次压入队列(当然是在左右儿子存在的情况下)
void CengOrder(Tnode T){  //层序遍历二叉树
 	if(!T)
 	   return;
	 else{
	   Tnode p=T;
 	   Tnode q;
	   queue<Tnode>s;
	   s.push(p);
	      while(!s.empty()){
 	          q=s.front();
 	          s.pop();
  	          cout<<q->data<<' ';
  	         if(q->lchild )   s.push(q->lchild );
 	         if(q->rchild ) s.push(q->rchild );
	     }
	}
}

4.7判断二叉树是否为完全二叉树

完全二叉树:通俗的讲就是对于k层的二叉树来说，k-1层为满二叉树，k层所有叶子结点左边靠齐。

我们借助队列来进行层序遍历，遍历的时候考虑以下情况

  1. 存在某个节点，其左子树不存在而右子树存在，则返回false
  2. 当遍历到k-1层时，对于k-1层的某个节点，如果其左子树不为空，而右子树为空，说明之后遍历的节点应该都为叶子节点，此时把isLeaf设置为true(对于k-1层和k层来说都是叶节点)
  3. 如果isLeaf状态已经开启，而存在某个节点来说，它不是叶子节点(有儿子)，返回false

代码如下

bool panduanwanquan(Tnode root){//判断二叉树是否为完全二叉树
	  if (root) {
 		 queue<BTnode*>que;
 	 	 que.push(root);
  		 bool isLeaf = false;
	 	 while (que.size()) {
  			 BTnode* p = que.front();
 			 que.pop();
  			 //如果左子树不存在 右子树存在 返回false
   			if (!p->lchild && p->rchild) {
   			    return false;
  			 }
 		  //左子树不为空 而右子树为空 说明之后节点都为叶子节点
  			 if (p->lchild && !p->rchild) {
   			 //若isLeaf状态已经开启 而该节点不是叶子节点 返回false
   			 if (isLeaf) {
    				 return false;
 			   }
   			 isLeaf = true;
    			que.push(p->lchild);
		   }
	   //左右子树都为空 说明之后节点都为叶子节点
	   	else if (!p->lchild && !p->rchild) {
   		 isLeaf = true;
  	 }
  	 //左右子树都不空
   	else {
   	     que.push(p->lchild);
    	    que.push(p->rchild);
   	}
 }
  	return true;        
 }
 return false;
 }

4.8 显示二叉树

我采取显示二叉树的策略是，对于树根节点p ,以及左子树q和右子树k，我的显示为(p(q,k))。空节点用’#'显示。

void xianshi(Tnode T){   //显示二叉树 
	 if(!T)  cout<<"#";
	 else{
	    cout<<"(";
	    cout<<T->data ;
 	    xianshi(T->lchild );
	    xianshi(T->rchild );
	    cout<<")"; 
	  }
	}

4.9非递归求二叉树的宽度

二叉树的宽度是指某一层最多的节点的个数。对于处理某一层的事件来说，我们一般都会借助队列来实现。
求二叉树的宽度的方法和层序遍历二叉树的方法很相似。
思路如下:

  1. 将根节点压入队列
  2. 始终循环一下步骤
    2.1 len = 当前队列的长度(表示的是当前某一层的节点个数)
    2.2 当len == 0 ,退出循环(表示已经层序遍历至最底层)
    //为了统计下一层的节点个数，我们需要把当前层的节点都从对了pop出去
    2.3 while(len > 0)//表示需要pop的节点的个数
    2.3.1 pop队列的首节点q
    2.3.2 len –
    2.3.3 把节点q的左儿子和右儿子压入队列
    (当把本层的所有节点pop完之后，我们队列中存储的都是下一层的节点，因此只要统计出len的最大值，就是我们想要的宽度)
int fwidth(Tnode T){   //非递归求二叉树的宽度 
	 if(T==NULL){
	     return 0;
	 }
	 int max=1;
	 queue<Tnode>s;
	 s.push(T); 
	 while(true){
 	    int len=s.size()  ;
	    if(len==0) break;
	    while(len>0){
	       Tnode t=s.front() ;
	       s.pop() ;
     	       len--;
   		if(t->lchild )
    		    s.push(t->lchild );
   		if(t->rchild )
    		    s.push(t->rchild );  
  	}
  	max=max>s.size() ? max:s.size();
 }
	 return max; 
}

在这里插入图片描述

5.实验代码如下

#include<iostream>
#include<fstream>
#include<stack>
#include<queue>
using namespace std;
typedef struct  BTnode *Tnode; //使用链式结构表示二叉树，
struct BTnode{     //声明一个树的节点，它包含这个节点的数据以及指向左儿子和右儿子的指针 
 char data;
 Tnode lchild,rchild;  //指向左右儿子的指针  
} ;
Tnode s1[100];     //用来创建递归树所用的数组 
Tnode CreatTree(){    //非递归创建二叉树 
 	int i,j;
 	char c;
 	Tnode bt,p;//用于存放节点
 
 	cin>>i>>c;
 	while(i!=0&&c!='#') {
 	     p=new BTnode;
 	     p->data =c;
  	     p->lchild =NULL;     
             p->rchild =NULL;
 	     s1[i]=p;
	     if(i==1) bt=p;
	     else if(i==2) bt->lchild =p;
  	     else{
 		   j=i/2;
  	          if(i%2==0) {
  	               s1[j]->lchild=p;
  		    }
  		  if(i%2!=0)   
  		  	s1[j]->rchild=p;
  } 
  	cin>>i>>c;
 }
	 return bt;
}


void PreCreatTree(Tnode *T){ //先序创建一个二叉树 
 	char x;
	 cin>>x;
	 if(x=='#'){//'#'表示空节点 
 	     *T=NULL;
	 } 
 	else{
	     *T=new BTnode;//给节点分配存储空间 
 	 if(!*T){
   	    cout<<"error"<<endl;
  	}
 	 else{
  	 //先序递归创建二叉树 
 	    (*T)->data =x;
  	    PreCreatTree(&(*T)->lchild );
 	    PreCreatTree(&(*T)->rchild );
  	     }     
        }
}


Tnode DuRuTree(){    //非递归创建二叉树 
 	fstream in;
	 in.open("erchashu.txt"); 
 	 int i,j;
	 char c;
	 Tnode bt,p;//用于存放节点
	 in>>i>>c;
	 while(i!=0&&c!='#') {
 	 	p=new BTnode;
 		p->data =c;
	        p->lchild =NULL;
	        p->rchild =NULL;
	        s1[i]=p;
 	       if(i==1) bt=p;
	       else if(i==2) bt->lchild =p;
 	       else{
 	           j=i/2;
 	           if(i%2==0){
 	           	s1[j]->lchild=p;
  	             }
 	  	if(i%2!=0)   s1[j]->rchild=p;
 	        } 
 	       in>>i>>c;
	 }
	 in.close() ;
	 return bt;
}

void PreOrder(Tnode T){   //先序递归遍历二叉树 
 	if(T==NULL){
  	    return ;
	 }
  	cout<<T->data<<" ";
 	PreOrder(T->lchild );
 	PreOrder(T->rchild );
}

void InOrder(Tnode T){   //中序递归遍历二叉树 
       if(T==NULL){
          return ;
      }
  InOrder(T->lchild );
  cout<<T->data<<" ";
  InOrder(T->rchild );
}
void PostOrder(Tnode T){  //后序递归遍历二叉树 
  if(T==NULL){
   return ;
  }
  PostOrder(T->lchild );
  PostOrder(T->rchild );
  cout<<T->data<<" ";
} 

void fPreOrder(Tnode root){  //非递归先序遍历二叉树 
	 if(root==NULL){
 	     return;
 	 }
 	Tnode p=root;
 	stack<Tnode>s;
	 while(!s.empty()||p){
	     while(p){
   		cout<<p->data<<' ' ;
   		s.push(p);
   		p=p->lchild ; 
  	      }
  	if(!s.empty() ){
        p=s.top() ;
        s.pop() ;
        p=p->rchild ;
       }
  }
}

void fInOrder(Tnode root){  //非递归中序遍历二叉树 
	 if(root==NULL)
   		return ;
	 Tnode p=root;
	 stack<Tnode>s;
	 while(!s.empty()||p){
	       while(p){
  	       s.push(p);
   		p=p->lchild ;
 	 }
	  if(!s.empty()){
	     p=s.top();
 	     s.pop();
 	     cout<<p->data<<' ' ;
  	     p=p->rchild ;
	}
	}
}

void fPostOrder(Tnode root){ //非递归后序遍历二叉树 
 	if(root==NULL){
	     return;
	 }
	 stack<Tnode>s;
	 Tnode pcur,plastvisit;//pcur是当前节点，plastxisit是上次访问的节点 
	 pcur=root;
	 plastvisit=NULL;
	 while(pcur){
	    s.push(pcur);
 	    pcur=pcur->lchild ;
	 }
 	 while(!s.empty() ){
 	     pcur=s.top() ;
 	     s.pop() ;
   	    if(pcur->rchild ==NULL||pcur->rchild ==plastvisit){
   		 cout<<pcur->data<<' ' ;
    		plastvisit=pcur;
   		}
  	    else{
            s.push(pcur);
            pcur=pcur->rchild ;
            while(pcur){
   	 	 s.push(pcur);
   	  	pcur=pcur->lchild ; 
		}
	   }
	}
}

void CengOrder(Tnode T){  //层序遍历二叉树
 	if(!T)
 	   return;
	 else{
	   Tnode p=T;
 	   Tnode q;
	   queue<Tnode>s;
	   s.push(p);
	      while(!s.empty()){
 	          q=s.front();
 	          s.pop();
  	          cout<<q->data<<' ';
  	         if(q->lchild )   s.push(q->lchild );
 	         if(q->rchild ) s.push(q->rchild );
	     }
	}
}

bool panduanwanquan(Tnode root){//判断二叉树是否为完全二叉树
	  if (root) {
 		 queue<BTnode*>que;
 	 	 que.push(root);
  		 bool isLeaf = false;
	 	 while (que.size()) {
  			 BTnode* p = que.front();
 			 que.pop();
  			 //如果左子树不存在 右子树存在 返回false
   			if (!p->lchild && p->rchild) {
   			    return false;
  			 }
 		  //左子树不为空 而右子树为空 说明之后节点都为叶子节点
  			 if (p->lchild && !p->rchild) {
   			 //若isLeaf状态已经开启 而该节点不是叶子节点 返回false
   			 if (isLeaf) {
    				 return false;
 			   }
   			 isLeaf = true;
    			que.push(p->lchild);
		   }
	   //左右子树都为空 说明之后节点都为叶子节点
	   	else if (!p->lchild && !p->rchild) {
   		 isLeaf = true;
  	 }
  	 //左右子树都不空
   	else {
   	     que.push(p->lchild);
    	    que.push(p->rchild);
   	}
 }
  	return true;        
 }
 return false;
 }

int fwidth(Tnode T){   //非递归求二叉树的宽度 
	 if(T==NULL){
	     return 0;
	 }
	 int max=1;
	 queue<Tnode>s;
	 s.push(T); 
	 while(true){
 	    int len=s.size()  ;
	    if(len==0) break;
	    while(len>0){
	       Tnode t=s.front() ;
	       s.pop() ;
     	       len--;
   		if(t->lchild )
    		    s.push(t->lchild );
   		if(t->rchild )
    		    s.push(t->rchild );  
  	}
  	max=max>s.size() ? max:s.size();
 }
	 return max; 
}

void xianshi(Tnode T){   //显示二叉树 
	 if(!T)  cout<<"#";
	 else{
	    cout<<"(";
	    cout<<T->data ;
 	    xianshi(T->lchild );
	    xianshi(T->rchild );
	    cout<<")"; 
	  }
	}

void zrh(){      //控制端函数 
	 int n;
	 Tnode t;
	 t=DuRuTree();
	 cout<<"当前从文件中读入的二叉树为："<<endl;
	 xianshi(t);//显示当前从文件读入的二叉树
	 cout<<endl; 
 	 cout<<"0.退出"<<endl;
	 cout<<"1.显示二叉树"<<endl; //实现 
	 cout<<"2.先序递归建立二叉树"<<endl;//实现 
 	 cout<<"3.非递归建立二叉树"<<endl;//实现 
 	 cout<<"4.先序递归遍历二叉树"<<endl;//实现 
	 cout<<"5.中序递归遍历二叉树"<<endl;//实现 
	 cout<<"6.后序递归遍历二叉树"<<endl;//实现 
	 cout<<"7.先序非递归遍历二叉树"<<endl;//实现 
	 cout<<"8.中序非递归遍历二叉树"<<endl;//实现 
	 cout<<"9.后序非递归遍历二叉树"<<endl;//实现 
  	 cout<<"10.层序遍历二叉树" <<endl;//实现 
	 cout<<"11.判断二叉树是否为完全树"<<endl;//实现 
	 cout<<"12.求二叉树的宽度"<<endl;  //实现 
	 cout<<"13.从文件读入并显示二叉树"<<endl; //实现
	 cin>>n;
 	 while(n!=0) {
  		switch(n){
		  case 1:
		        cout<<"当前二叉树为：";
		        xianshi(t);//显示二叉树 
		        cout<<endl;
		        break;
	          case 2:
  			 cout<<"2.先序递归建立二叉树(空节点用'#'表示)"<<endl;//实现
  			 PreCreatTree(&t);
   			  break; 
		  case 3:
   			cout<<"3.非递归建立二叉树(依次输入节点的标号和内容，输入0或#结束)："<<endl;
 			 t=CreatTree();
  			break; 
  		  case 4:
  			 cout<<"当前二叉树为：";xianshi(t);cout<<endl;
   			 cout<<"4.先序递归遍历二叉树的结果为："<<endl;
 			  PreOrder(t);
  			 cout<<endl;
  			 break; 
 		  case 5:
  			 cout<<"当前二叉树为：";xianshi(t);cout<<endl;
   			 cout<<"5.中序递归遍历二叉树的结果为："<<endl;
   			 InOrder(t);
			 cout<<endl;
			 break; 
		  case 6:
  	 		cout<<"当前二叉树为：";xianshi(t);cout<<endl;
  			cout<<"6.后序递归遍历二叉树的结果为："<<endl;
 			PostOrder(t);
  	 		cout<<endl;
  	 		break; 
		  case 7:
  			 cout<<"当前二叉树为：";xianshi(t);cout<<endl;
  			 cout<<"7.先序非递归遍历二叉树的结果为："<<endl;
 			 fPreOrder(t);
 			 cout<<endl;
 			 break; 
  		  case 8:
   			cout<<"当前二叉树为：";xianshi(t);cout<<endl;
 			cout<<"8.中序递归遍历二叉树的结果为："<<endl;
 			fInOrder(t);
 			cout<<endl;
			break; 
 	  	  case 9:
  			 cout<<"当前二叉树为：";xianshi(t);cout<<endl;
			 cout<<"9.后序递归遍历二叉树的结果为："<<endl;
 			 fPostOrder(t);
  			 cout<<endl;
			 break; 
 		  case 10:
   			cout<<"当前二叉树为：";xianshi(t);cout<<endl;
   			cout<<"10.层序遍历二叉树的结果为："<<endl;
   			CengOrder(t);
  			cout<<endl;
  			break;  
 		 case 11:
  			 cout<<"当前二叉树为：";xianshi(t);cout<<endl;
  			 cout<<"当前二叉树为完全二叉树？(1：是，2：不是)："<<panduanwanquan(t);
   			 cout<<endl;
  			 break;
	 	 case 12:
 		  	cout<<"当前二叉树为：";xianshi(t);cout<<endl;
		        cout<<"当前二叉树的宽度为："<<fwidth(t);
 		 	cout<<endl;
		        break;
  		case 13:
  		 	cout<<"13.当前从文件读入的二叉树为："<<endl;
  			t=DuRuTree();
  			xianshi(t);
			cout<<endl;
 			break;
 		case 0:
   			n=0;
  			break; 
  			default:
  	  		cout<<"请输入0-13的数据："<<endl;
 	 	         break;
 } 
	 if(n==0)  break;
	 cout<<"0.退出"<<endl;
 	 cout<<"1.显示二叉树"<<endl; 
	 cout<<"2.先序递归建立二叉树"<<endl;
	 cout<<"3.非递归建立二叉树"<<endl;
 	 cout<<"4.先序递归遍历二叉树"<<endl;
 	 cout<<"5.中序递归遍历二叉树"<<endl;
	 cout<<"6.后序递归遍历二叉树"<<endl;
	 cout<<"7.先序非递归遍历二叉树"<<endl;
	 cout<<"8.中序非递归遍历二叉树"<<endl;
	 cout<<"9.后序非递归遍历二叉树"<<endl;
	 cout<<"10.层序遍历二叉树" <<endl;
	 cout<<"11.判断二叉树是否为完全树"<<endl;
	 cout<<"12.求二叉树的宽度"<<endl; 
	 cout<<"13.从文件读入二叉树"<<endl; 
	 cin>>n;
 }
} 

int main(){
 zrh();//调用控制端函数 
}
dream or nightmare
关注
专栏目录
哈工大数据结构与算法实验
10-22
这个实验环节旨在培养学生的逻辑思维和问题解决能力，同时熟悉常见的数据结构——栈的应用。 其次，树是一种非线性数据结构，广泛用于表示层次关系和组织复杂的数据。实验中的树部分可能涵盖了二叉树、AVL树、红黑...
哈工大数据结构实验二 树形结构及其应用
码蹄疾
07-20 3291
实验二 树形结构及其应用 实验内容：树型结构的建立与遍历 树型结构的遍历是树型结构算法的基础，本实验要求编写程序演示二叉树的存储结构的建立和遍历过程。 实验要求： (1) 至少用两种方法，编写建立二叉树的二叉链表存储结构的程序，并用广义表的形式显示并保存二叉树； (2) 采用二叉树的二叉链表存储结构，编写程序实现二叉树的先序、中序和后序遍历的递归和非递归算法以及层序遍
哈工大数据结构作业3-树形结构及其应用
qq_45853731的博客
07-12 1131
  本文是笔者2020年秋哈工大数据结构作业3自己的代码，由于本人能力有限，可能存在一些错误，欢迎指出。   本文仅供参考，严禁抄袭！ 文章目录作业题目：二叉树存储结构的建立、遍历和应用编写建立二叉树的二叉链表存储结构（左右链表示）的程序，并以适当的形式显示和保存二叉树采用二叉树的二叉链表存储结构，编写程序实现二叉树的先序、中序和后序遍历的递归和非递归算法以及层序遍历算法，并以适当的形式显示和保存二叉树及其相应的遍历序列设计并实现判断任意一棵二叉树是否为完全二叉树的算法设计并实现计算任意一棵二叉树的宽度的（
哈工大 数据结构与算法 作业3-树形结构及其应用
TC_Ning的博客
10-10 1067
作业题目：二叉树存储结构的建立、遍历和应用 树型结构的遍历是树型结构算法的基础，本实验要求编写程序演示二叉树 的存储结构的建立方法、遍历过程以及应用。 作业要求： 1．编写建立二叉树的二叉链表存储结构（左右链表示）的程序，并以适当的形 式显示和保存二叉树； 2．采用二叉树的二叉链表存储结构，编写程序实现二叉树的先序、中序和后序 遍历的递归和非递归算法以及层序遍历算法，并以适当的形式显示和保存二叉树 及其相应的遍历序列； 3．设计并实现判断任意一棵二叉树是否为完全二叉树的算法。 4．设计并实现计算
数据结构之二叉树的构建与遍历
最新发布
zhqi9277的博客
04-26 623
按照已知二叉树，从键盘读入节点字符，建立二叉树（例如：ABD#G###CE##FH###）；分别采用先序、中序、后序、按层遍历该二叉树，分别输出遍历结果。提示：以下是本篇文章正文内容，下面案例可供参考采用递归的复杂度分析：时间复杂度为O(n)，其中n为二叉树的节点数。空间复杂度为O(h)，其中h为二叉树的高度，因为该算法使用了递归，每次递归会消耗一定的系统栈空间。未采用递归的复杂度分析：使用了栈来模拟递归过程，时间复杂度为O(n)，其中n为二叉树的节点数。
【数据结构】二叉树的遍历及应用
热门推荐
不用先生的博客
06-08 2万+
  【fishing-pan：https://blog.csdn.net/u013921430转载请注明出处】 前言       在二叉树的应用中，常常要求在树中查找某些结点，或者对树中的结点统一进行某种处理。因此，就提到了二叉树的遍历问题，对于线性结构来说，遍历是一个很容易解决的问题，而二叉树偏偏是一种非线性的结构，因此需要寻找一种规律。        二叉树由三个基本单元组成，分别是根...
哈工大 数据结构与算法课件
07-28
哈工大的数据结构课件，以其深入浅出的讲解方式，成为了许多学习者掌握这一领域知识的重要资源。下面将详细阐述课件中涉及的三个主要章节：线性表、树和图。 首先，我们来看第3章——线性表。线性表是最基础的数据...
哈工大数据结构课件
04-15
哈工大的数据结构课程由李秀坤老师讲授，涵盖1-4章的内容，这通常包括了数据结构的基础概念、线性结构和非线性结构的介绍。 首先，我们从第一章节开始。第一章通常会引入数据结构的基本概念，如什么是数据、什么是...
数据结构试验
12-08
在这个“数据结构试验”中，我们很显然会接触到一系列与数据结构相关的编程实践，包括但不限于数组、链表、栈、队列、树、图、哈希表等基本数据结构以及它们的操作算法。 数组是一种线性数据结构，它提供了通过索...
数据结构实验五（二叉树的建立及遍历）题目和源程序
04-02
实验内容 1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。 2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
哈工大数据结构实验全代码
01-07
哈尔滨工业大学2012级软件学院数据结构实验代码
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问结点的操作修改为叶结点计数，统计度为0的；度为1的；度为2的；总结点数。 6.用递归公式计算二叉树的高度（BiTreeDepth(BT)=0; 当二叉树空时（BT==NULL）。 BiTreeDepth(BT)=max{ BiTreeDepth(BT->lchild), BiTreeDepth(BT->rchild)}+1;当二叉树不空时
二叉树的建立与遍历
10-15
按先序序列构造一棵二叉链表表示的二叉树T，并输出该T的中序遍历序列。实现提示： 1) 按先序序列建立一棵二叉树时，先构造根结点，再构造根的左子树，然后构造右子树；每棵子树又都是二叉树，所以构造一棵子树的过程与构造整棵二叉树的过程完全相同（采用递归形式直到叶子结点为止）。 2) 先序序列的输入：从键盘输入任意一棵二叉树的先序序列，用#代表空指针，如下图所示的二叉树，输入的先序序列为：ab#d##c##）。
哈工大数据结构实验二_树形结构及其应用
03-26
实验项目：树型结构的建立、遍历和应用 实验题目：二叉树存储结构的建立、遍历和应用 实验内容： 树型结构的遍历是树型结构算法的基础，本实验要求编写程序演示二叉树 的存储结构的建立方法、遍历过程以及应用。 实验要求： 1．至少采用两种方法，编写建立二叉树的二叉链表存储结构（左右链表示）的 程序，并以适当的形式显示和保存二叉树； 2．采用二叉树的二叉链表存储结构，编写程序实现二叉树的先序、中序和后序 遍历的递归和非递归算法以及层序遍历算法，并以适当的形式显示和保存二叉树 及其相应的遍历序列； 3．设计并实现判断任意一棵二叉树是否为完全二叉树的算法。 4．设计并实现计算任意一棵二叉树的宽度的（递归或非递归）算法。二叉树的 宽度是指其各层结点数的最大值。 代码有详细注释
二叉树遍历及其应用
q793145253的博客
01-10 1609
二叉树的三种遍历算法的递归实现 特别说明：函数形参中的 void(*visit)(BinTreeNode *p) 代表：采用一个visit的指针指向某个函数，该函数的形参为BinTreeNode *p，该函数的实现体中可以对结点进行处理，传参时将外部函数名传入即可 前、中、后的差别仅在于 visit(subTree) 该语句的位置不同 1、前序遍历 template<class T> void PreOrder(BinTreeNode<T> *subTree, void(*visit
二叉树的建立、遍历及其应用（递归建立二叉树，顺序表建立二叉树）
莞工杰仔的博客
05-23 1395
通过二叉树的相关操作深刻理解递归算法以及二叉树的操作算法 最近已经很久没写博客主要是因为没时间，不过最近的这个二叉树我着实又很多的感悟，所以尽管要花时间，我还是想要写下来，希望对大家也有帮助，我会先从二叉树的一些性质讲起，并讲明该性质的作用，最后附上一道综合题及代码详解帮助大家理解 首先是二叉树的性质，及一些重要的算法 1.对于具有n个节点的二叉树，如果按照从上到下从左到右的顺序对所有的节点从零开始顺序编号，则对于i(0<=i<=n)的节点，有： （1）如果i>0,则序号为i的节点的双亲节
二叉树的建立、遍历及应用
m0_62901089的博客
11-27 425
【代码】二叉树的建立、遍历及应用。
数据结构实验(二叉树的建立、遍历和应用)
qq_45297146的博客
01-19 6894
实验名称：二叉树的建立、遍历和应用 实验目的： 掌握二叉树这种抽象数据类型的特点；熟练掌握二叉树的链式存储结构的描述方法和具体实现。 实验要求： 基于二叉树的二叉链表存储结构实现以下操作： 用先序遍历方法创建二叉树 对二叉树进行后序递归遍历和中序非递归遍历 求二叉树的所有结点个数、叶子结点个数 求二叉树的深度 交换二叉树的左右子树（交换后可再次遍历） 实验说明： 用菜单调用实现各个功能 按照...
数据结构实验：创建二叉树并遍历
这篇实验报告涉及的是数据结构中的二叉树知识，具体来说，实验的目标是掌握二叉树的存储结构，实现二叉树的三种遍历方法（先序、中序、后序），以及理解树和森林与二叉树之间的转换。实验内容包括创建一个二叉树，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值