二叉树，树，森林

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量324 收藏 6
点赞数 1
分类专栏： 数据结构-二叉树-树-森林 文章标签： 二叉树 树结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44384477/article/details/105523481
版权

1.统计二叉树双孩子/单孩子/叶子结点数

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//本题一定注意怎么避免全局变量的使用，通过递归实现算法
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;

//创建二叉树
twotree creat()
{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}


//统计双孩子结点
int doublec(twotree tree)
{
    int bencengjiedian;
    if(!tree)
    {
        return 0;
    }
    if(tree->lc&&tree->lc)//如果此节点左右都有
    {
        bencengjiedian=1;
    }
    else
    {
        bencengjiedian=0;
    }
    return bencengjiedian+doublec(tree->lc)+doublec(tree->rc);
}

//统计单孩子节点
int singlec(twotree tree)
{
    int bencengjiedian0;
    if(!tree)
    {
        return 0;
    }
    if((tree->lc&&!tree->rc)||(tree->rc&&!tree->lc))//左右至少空了一个
    {
        bencengjiedian0=1;
    }
    else
    {
        bencengjiedian0=0;
    }
    return bencengjiedian0+singlec(tree->lc)+singlec(tree->rc);
}

//统计叶子
int leaf(twotree tree)
{
    if(!tree)
    {
        return 0;
    }
    if(!tree->lc&&!tree->rc)
    {
        return 1;
    }
    return leaf(tree->lc)+leaf(tree->rc);


}
int main()
{
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABD##EH###CF#I##G##)\n");
	twotree T;
	T=creat();
	shuchu(T,visit);
	printf("\n");
	int cnt1;
	int cnt2;
	int cnt3;
	cnt1=doublec(T);
	cnt2=singlec(T);
	cnt3=leaf(T);
	cout<<"共有"<<cnt1<<"个具有双孩子的结点"<<endl;
	cout<<"共有"<<cnt2<<"个具有单孩子的结点"<<endl;
	cout<<"共有"<<cnt3<<"个叶子结点"<<endl;

}

2.判断严格二叉树

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//本题一定注意怎么避免全局变量的使用，通过递归实现算法
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;

//创建二叉树
twotree creat()
{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}

//判断严格二叉树
bool panduan(twotree tree)
{
    if(!tree)
    {
        return true;
    }
    if((!tree->lc&&tree->rc)||(!tree->rc&&tree->lc))
    {
        return false;
    }
    return panduan(tree->lc)&&panduan(tree->rc);
}

int main()
{
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABD##EH###CF#I##G##)\n");
	twotree T;
	T=creat();
	shuchu(T,visit);
	printf("\n");
	if(panduan(T))
    {
        printf("是严格的\n");
    }
    else
    {
        printf("不是严格的\n");
    }
    return 0;

}

3.寻找二叉树有无x结点

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;

//创建二叉树
twotree creat()
{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}

//寻找x结点
twotree found(twotree tree,char x)
{
    twotree tree0;
    if(!tree)
    {
        return NULL;
    }
    if(x==tree->fuhao)
    {
        return tree;
    }
    tree0=found(tree->lc,x);
    if(tree0)
    {
        return tree0;
    }
    return found(tree->rc,x);
}

int main()
{
    char zifu;
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABD##EH###CF#I##G##)\n");
	twotree T;
	T=creat();
	printf("请输入您想要查找的字符：\n");
	cin>>zifu;
	shuchu(T,visit);
	printf("\n");
	if(found(T,zifu))
    {
       cout<<"x的地址为"<<found(T,zifu)<<endl;
    }
    else
    {
        cout<<"没找到x"<<endl;
    }

}

4.求以x为根节点的子树深度

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;

//创建二叉树
twotree creat()
{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}

//寻找x结点
twotree found(twotree tree,char x)
{
    twotree tree0;
    if(!tree)
    {
        return NULL;
    }
    if(x==tree->fuhao)
    {
        return tree;
    }
    tree0=found(tree->lc,x);
    if(tree0)
    {
        return tree0;
    }
    return found(tree->rc,x);
}
//利用寻找到的x结点的地址，来找x子树深度
int depth(twotree tree)
{
    int dl,dr;
    if(!tree)
    {
        return 0;
    }
    dl=depth(tree->lc);
    dr=depth(tree->rc);
    if(dl>dr)
    {
        return dl+1;
    }
    else
    {
        return dr+1;
    }
}
int depth1(twotree tree,char x)
{
    return depth(found(tree,x));
}

int main()
{
    char zifu;
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABD##EH###CF#I##G##)\n");
	twotree T;
	T=creat();
	printf("请输入您想要查找的字符：\n");
	cin>>zifu;
	shuchu(T,visit);
	printf("\n");
	if(depth1(T,zifu))
    {
       cout<<"以x为结点的子树的深度为"<<depth1(T,zifu)<<endl;
    }
    else
    {
        cout<<"没找到x"<<endl;
    }

}

5.删除二叉树中所有根节点为x的子树

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;

//创建二叉树
twotree creat()
{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}


//删除二叉树
void deletetree(twotree &tree)
{
    if(!tree)
    {
        return;
    }
    deletetree(tree->lc);
    deletetree(tree->rc);
    delete tree;
}
//删除以x为根的二叉树
void deletextree(twotree &tree,char x)
{
    if(!tree)
    {
        return;
    }
    if(tree->fuhao==x)
    {
        deletetree(tree);
        tree=NULL;
    }
    else
    {
        deletextree(tree->lc,x);
        deletextree(tree->rc,x);
    }
}
int main()
{
    char zifu;
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABXE##F##D##CXH##X##G##)\n");
	twotree T;
	T=creat();
	printf("请输入您想要查找的字符：\n");
	cin>>zifu;
	cout<<"您输入的二叉树广义表表示为："<<endl;
	shuchu(T,visit);
	printf("\n");
	deletextree(T,zifu);
    cout<<"删除x根节点的子树后的二叉树广义表表示为："<<endl;
    shuchu(T,visit);
}

6.判断完全二叉树

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//定义二叉树
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;
//定义链队列
typedef struct Qnode
{
    twotree data;
    Qnode *next;
}*lianduilie;
struct liandui
{
    lianduilie front,rear;
};
//初始化链队
void duiinit(liandui &Q)
{
    Q.front=new Qnode;
    Q.front->next=NULL;
    Q.rear=Q.front;
}
//入队
void Enqueue(liandui &Q,twotree e)
{
    lianduilie p;
    p=new Qnode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
}
bool Dequeue(liandui &Q,twotree &e)
{
    lianduilie p;
    if(Q.front==Q.rear)
    {
        return false;
    }
    p=Q.front;
    Q.front=p->next;
    e=Q.front->data;
    delete p;
    return true;

}
//创建二叉树
twotree creat()

{
	twotree tree;
	char c;
	c=getchar();
	if(c=='#')
    {
        tree=NULL;
    }
	else
    {
	   tree=(twotree)malloc(sizeof(erchashu));
	   tree->fuhao=c;
	   tree->lc=creat();
	   tree->rc=creat();
	}
	return tree;
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}
//判断完全二叉树
bool panduan(twotree tree)
{
    liandui q;
    twotree p;
    if(!tree)
    {
        return true;
    }
    duiinit(q);
    Enqueue(q,tree);
    while(Dequeue(q,p))
    {
        if(!p)
        {
            break;
        }
        Enqueue(q,p->lc);
        Enqueue(q,p->rc);
    }
    while(Dequeue(q,p))
    {
        if(p)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    char zifu;
    printf("请以先序序列输入您的二叉树，并用“#”表示取消建立子树节点(例如:ABD##EH###CF#I##G##)\n");
	twotree T;
	T=creat();
	shuchu(T,visit);
	printf("\n");
	if(panduan(T))
    {
       cout<<"是完全二叉树"<<endl;
    }
    else
    {
        cout<<"不是完全二叉树"<<endl;
    }

}

7.先序遍历+中序遍历建立二叉链表

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;
bool chuangzaoerchashu(twotree &T,char A[],char B[],int n)
{
   int k;
   if(n==0)
   {
       T=NULL;
       return true;
   }
   k=0;
   while(k<n&&B[k]!=A[0])
   {
       k++;
   }
   if(k==n)
   {
       T=NULL;
       return false;
   }
   T=new erchashu;
   T->fuhao=A[0];
   return chuangzaoerchashu(T->lc,A+1,B,k)&&chuangzaoerchashu(T->rc,A+k+1,B+k+1,n-k-1);
}
//广义表输出二叉树
void visit(char e)
{
    cout<<e;
}
void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->lc||tree->rc)
	{
		cout<<'(';
		shuchu(tree->lc,visit);
		cout<<',';
		shuchu(tree->rc,visit);
		cout<<')';
	}
}
int main()
{
    twotree T;
    int n;
    cout<<"请输入二叉树的结点个数："<<endl;
    cin>>n;
    char *A=(char *)malloc(sizeof(char)*n);
    char *B=(char *)malloc(sizeof(char)*n);
    cout<<"请输入二叉树的先序序列"<<endl;
    int i;
    for(i=0;i<n;i++)
    {
        cin>>A[i];
    }
    cout<<"请输入二叉树的中序序列"<<endl;
    for(i=0;i<n;i++)
    {
        cin>>B[i];
    }
    if(chuangzaoerchashu(T,A,B,n))
    {
        shuchu(T,visit);
    }

    return 0;
}

8.二叉树广义表形式输入建立二叉链表

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct erchashu
{
	char fuhao;
	erchashu* lc;//左
	erchashu* rc;//右
}*twotree;
bool chuangzaoerchashu(twotree &T,char A[],int n,int &i)
{
   i++;
   if(i==n)
   {
       return false;
   }
   if(A[i]=='#')
   {
       T=NULL;
       return true;
   }
   if(A[i]<'A'||A[i]>'Z')
   {
       return false;
   }
   T=new erchashu;
   T->fuhao=A[i];
   if(i==n-1||A[i+1]==','||A[i+1]==')')
   {
       T->lc=NULL;
       T->rc=NULL;
       return true;
   }
   if(A[i+1]!='(')
   {
       return false;
   }
   i++;
   if(!chuangzaoerchashu(T->lc,A,n,i))
   {
       return false;
   }
   i++;
   if(i==n||A[i]!=',')
   {
       return false;
   }
   if(!chuangzaoerchashu(T->rc,A,n,i))
   {
       return false;
   }
   if(!T->lc&&!T->rc)
   {
       return false;
   }
   i++;
   if(i==n||A[i]!=')')
   {
       return false;
   }
   return true;
}
bool chuangzaoerchashu(twotree &T,char A[])
{
    int i=-1;
    int n=strlen(A);
    return chuangzaoerchashu(T,A,n,i)&&(i==n-1);
}
//先序序列输出二叉树
void visit(char e)
{
    cout<<e;
}

void shuchu(twotree tree,void visit(char))
{
	if(!tree)
    {
        return;
    }
    visit(tree->fuhao);
    shuchu(tree->lc,visit);
    shuchu(tree->rc,visit);
}

int main()
{
    twotree T;
    char A[100];
    cout<<"请输入二叉树的广义表形式,例如：A(C(G(#,J),E(I(K,#),L)),B(D(#,H),F))"<<endl;
    cin>>A;
    if(chuangzaoerchashu(T,A))
    {
       shuchu(T,visit);
    }
    return 0;
}

9.森林的层序遍历

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
//定义二叉树
typedef struct senlin
{
	char fuhao;
	senlin* fc;//左孩子
	senlin* ns;//右兄弟
}*forest,*tree;
//定义链队列
typedef struct Qnode
{
    forest data;
    Qnode *next;
}*lianduilie;
struct liandui
{
    lianduilie front,rear;
};
//初始化链队
void duiinit(liandui &Q)
{
    Q.front=new Qnode;
    Q.front->next=NULL;
    Q.rear=Q.front;
}
//入队
void Enqueue(liandui &Q,forest e)
{
    lianduilie p;
    p=new Qnode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
}
bool Dequeue(liandui &Q,forest &e)
{
    lianduilie p;
    if(Q.front==Q.rear)
    {
        return false;
    }
    p=Q.front;
    Q.front=p->next;
    e=Q.front->data;
    delete p;
    return true;

}
//创建森林
forest creat()
{
	forest sensen;
	char c;
	c=getchar();
	if(c=='#')
    {
        sensen=NULL;
    }
	else
    {
	   sensen=(forest)malloc(sizeof(senlin));
	   sensen->fuhao=c;
	   sensen->fc=creat();
	   sensen->ns=creat();
	}
	return sensen;
}
//广义表输出森林
void visit(char e)
{
    cout<<e;
}
void shuchu(forest tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->fc||tree->ns)
	{
		cout<<'(';
		shuchu(tree->fc,visit);
		cout<<',';
		shuchu(tree->ns,visit);
		cout<<')';
	}
}
//层序遍历森林
void cengxv(forest T,void visit(char))
{
    liandui q;
    tree x,y;
    if(!T)
    {
        return;
    }
    duiinit(q);
    for(x=T;x;x=x->ns)
    {
        Enqueue(q,x);
    }
    while(Dequeue(q,x))
    {
        visit(x->fuhao);
        for(y=x->fc;y;y=y->ns)
        {
            Enqueue(q,y);
        }
    }
}

int main()
{
    printf("请以先序序列输入您的森林（二叉树形式），并用“#”表示取消建立子树节点(例如:ADG#I##F#J##BCE###H##)\n");
	forest T;
	T=creat();
	cout<<"您输入的森林的广义表表示为：";
	shuchu(T,visit);
	printf("\n");
	cout<<"层序遍历的结果为:";
	cengxv(T,visit);
}

10.统计树度为1和度为2的结点数目

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct senlin
{
	char fuhao;
	senlin* fc;//左孩子
	senlin* ns;//右兄弟
}*forest,*tree;
//定义链队列
typedef struct Qnode
{
    forest data;
    Qnode *next;
}*lianduilie;
struct liandui
{
    lianduilie front,rear;
};
//初始化链队
void duiinit(liandui &Q)
{
    Q.front=new Qnode;
    Q.front->next=NULL;
    Q.rear=Q.front;
}
//入队
void Enqueue(liandui &Q,forest e)
{
    lianduilie p;
    p=new Qnode;
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
}
bool Dequeue(liandui &Q,forest &e)
{
    lianduilie p;
    if(Q.front==Q.rear)
    {
        return false;
    }
    p=Q.front;
    Q.front=p->next;
    e=Q.front->data;
    delete p;
    return true;

}
//创建
forest creat()
{
	forest sensen;
	char c;
	c=getchar();
	if(c=='#')
    {
        sensen=NULL;
    }
	else
    {
	   sensen=(forest)malloc(sizeof(senlin));
	   sensen->fuhao=c;
	   sensen->fc=creat();
	   sensen->ns=creat();
	}
	return sensen;
}
//广义表输出
void visit(char e)
{
    cout<<e;
}
void shuchu(forest tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->fc||tree->ns)
	{
		cout<<'(';
		shuchu(tree->fc,visit);
		cout<<',';
		shuchu(tree->ns,visit);
		cout<<')';
	}
}
//统计结点的度
int cnt1(tree T)
{
    int n;
    tree p;
    if(!T)
    {
        return 0;
    }
    p=T->fc;
    if(p&&!p->ns)
    {
        n=1;
    }
    else
    {
        n=0;
    }
    return n+cnt1(p)+cnt1(T->ns);
}
int cnt2(tree T)
{
    int n;
    tree p;
    if(!T)
    {
        return 0;
    }
    p=T->fc;
    if(p&&p->ns&&!p->ns->ns)
    {
        n=1;
    }
    else
    {
        n=0;
    }
    return n+cnt2(p)+cnt2(T->ns);
}

int main()
{
    printf("请以先序序列输入您的树（二叉树形式），并用“#”表示取消建立子树节点(例如:ABD#EG##H##CF#J##I#K###)\n");
	forest T;
	T=creat();
	cout<<"您输入的森林的广义表表示为：";
	shuchu(T,visit);
	printf("\n");
	cout<<"度为1的结点个数为:"<<cnt1(T)<<endl;
	cout<<"度为2的结点个数为:"<<cnt2(T)<<endl;
}

11.求非空树的度

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct senlin
{
	char fuhao;
	senlin* fc;//左孩子
	senlin* ns;//右兄弟
}*forest,*tree;
typedef tree QElemType;
#include "queue.cpp"
//创建
forest creat()
{
	forest sensen;
	char c;
	c=getchar();
	if(c=='#')
    {
        sensen=NULL;
    }
	else
    {
	   sensen=(forest)malloc(sizeof(senlin));
	   sensen->fuhao=c;
	   sensen->fc=creat();
	   sensen->ns=creat();
	}
	return sensen;
}
//广义表输出
void visit(char e)
{
    cout<<e;
}
void shuchu(forest tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->fc||tree->ns)
	{
		cout<<'(';
		shuchu(tree->fc,visit);
		cout<<',';
		shuchu(tree->ns,visit);
		cout<<')';
	}
}

//计算树的度
int degree(tree T)
{
    int d,dd;
    liandui q;
    tree x,y;
    if(!T)
    {
        return -1;
    }
    duiinit(q);
    Enqueue(q,T);
    d=0;
    while(Dequeue(q,x))
    {
        for(dd=0,y=x->fc;y;y=y->ns)
        {
            dd++;
            Enqueue(q,y);
        }
        if(dd>d)
        {
            d=dd;
        }
    }
    return d;
}


int main()
{
    printf("请以先序序列输入您的树（二叉树形式），并用“#”表示取消建立子树节点(例如:ABD#EG##H##CF#J##I#K###)\n");
	forest T;
	T=creat();
	cout<<"您输入的树的广义表表示为：";
	shuchu(T,visit);
	printf("\n");
	cout<<"树的度为:"<<degree(T)<<endl;
}

12.求树的深度

#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef struct senlin
{
	char fuhao;
	senlin* fc;//左孩子
	senlin* ns;//右兄弟
}*forest,*tree;

//创建
forest creat()
{
	forest sensen;
	char c;
	c=getchar();
	if(c=='#')
    {
        sensen=NULL;
    }
	else
    {
	   sensen=(forest)malloc(sizeof(senlin));
	   sensen->fuhao=c;
	   sensen->fc=creat();
	   sensen->ns=creat();
	}
	return sensen;
}
//广义表输出
void visit(char e)
{
    cout<<e;
}
void shuchu(forest tree,void visit(char))
{
	if(!tree)
    {
        cout<<'#';
        return;
    }
	visit(tree->fuhao);
	if(tree->fc||tree->ns)
	{
		cout<<'(';
		shuchu(tree->fc,visit);
		cout<<',';
		shuchu(tree->ns,visit);
		cout<<')';
	}
}

//求树的深度
int depth(tree T)
{
    int dzuo,dyou;
    if(!T)
    {
        return 0;
    }
    dzuo=depth(T->fc)+1;
    dyou=depth(T->ns);
    if(dzuo>dyou)
    {
        return dzuo;
    }
    else
    {
        return dyou;
    }
}

int main()
{
    printf("请以先序序列输入您的树（二叉树形式），并用“#”表示取消建立子树节点(例如:ABD#EG##H##CF#J##I#K###)\n");
	forest T;
	T=creat();
	cout<<"您输入的树的广义表表示为：";
	shuchu(T,visit);
	printf("\n");
	cout<<"树的深度为:"<<depth(T)<<endl;
}
春野与望
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树、二叉树和森林的转换
01-22
树、二叉树和森林的转换
树（二叉树+树+森林）
xyl
04-30 1715
树 树的基本概念 树是一个n(n>=0)个结点的有序合集 结点：指树中的一个元素； 结点的度：指结点拥有的子树的个数，二叉树的度不大于2； 树的度：指树中的最大结点度数； 叶子：度为0的结点，也称为终端结点； 高度：叶子节点的高度为1，根节点高度最高； 层：根在第一层，以此类推； 节点的深度：从上到下 节点的高度：从下到上1 路径长度：经过的边的个数 森林：好多树，通常树去掉根结点就是森...
数据结构复习之线索二叉树 森林与二叉树相互转化
guangod的博客
07-17 747
线索二叉树与森林线索二叉树定义结点结构线索链表定义二叉树线索化算法思想二叉链表加中序线索算法线索链表上运算在中序线索二叉树上查找某结点*p的后继结点算法实现线索二叉树中序遍历森林和树树的存储结构双亲表示法孩子链表表示法带双亲孩子链表表示法孩子兄弟表示法树，森林与二叉树转换树转换成二叉树森林转换成二叉树二叉树转换为树二叉树还原为森林树与森林的遍历树的遍历树的前序遍历定义：树的后序遍历定义：森林遍历前序遍历后序遍历 线索二叉树 定义 n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向结
树、森林与二叉树的相互转换
薛定谔的猫的博客
07-26 2万+
文章目录树转换为二叉树 树转换为二叉树  二叉树和树都可以用二叉链表作为存储结构，因此二叉链表可以导出树与二叉树的一个对应关系，即给定一棵树，可以找到唯一的一棵二叉树与之对应。其中树的二叉链表存储详情可参照树的存储结构及详细完整代码。  树转换成二叉树的规则：  <1>每个结点的左指针指向它的第一个孩子结点；  <2>每个结点的右指针指向它在树中的相邻兄弟结点。  可表示为"左孩子右兄弟"。 ...
树、森林与二叉树的转换
热门推荐
CSDN
12-30 14万+
树、森林与二叉树的转换 1、树转换为二叉树 由于二叉树是有序的，为了避免混淆，对于无序树，我们约定树中的每个结点的孩子结点按从左到右的顺序进行编号。 将树转换成二叉树的步骤是： （1）加线。就是在所有兄弟结点之间加一条连线； （2）抹线。就是对树中的每个结点，只保留他与第一个孩子结点之间的连线，删除它与其它孩子结点之间的连线； （3）旋转。就是以树的根结点为轴心，将整棵树顺时针旋转一定...
树、二叉树与森林的转换
m0_64985004的博客
05-05 6275
1.树转换为二叉树 上图是一个度为3的树的结构 ，转换为二叉树分为加线、抹线和旋转几个过程： ①加线：在所有兄弟节点间加一条线 ②抹线：只保留他与第一个孩子结点间的连线，删除它与其它孩子结点间的连线 ③旋转：以树的根节点为轴心，将整棵树顺时针旋转一定角度使结构层次分明 2.森林转换为二叉树 森林是由若干棵树组成的，可以将森林中每根树的根节点看作是兄弟节点，由于每棵树都可转换为二叉树，故森林也可转换为二叉树。下图是一个森林： ①把每棵树转换为二叉树 ②第一棵二叉树不动，从第二棵
数据结构5.12树、森林与二叉树的转换
11-19
本讲在对二叉树各类存储方法了解基础上，简单介绍树和森林与二叉树间的转换。
树与森林实验
04-09
(2)掌握树和二叉树的结构及算法之间的对应关系。 (3)掌握树的两种遍历算法及其应用。 2.实验任务 设计、实现算法求解下列问题： (1)按先序、后序、层次遍历森林。 实验测试数据基本要求： 第一组数据： tree11...
二叉树与树、森林的转换（数据结构课设）
06-21
树型结构是一类重要的...其中以二叉树最为常用，直观看来树是以分支关系定义的层次结构。 二叉树的建立可用递归法来建立。将二叉树还原成树或森林时可用队列作为中间变量来转换。树或森林的遍历也可用递归法进行遍历。
树和二叉树
10-26
树和二叉树PPT 6.1 树的定义和基本术语 6.2 二叉树 6.2.1 二叉树的定义 6.2.2 二叉树的性质 6.2.3 二叉树的存储结构 6.3 遍历二叉树线索二叉树 6.3.1 遍历二叉树 6.3.2 线索二叉树 6.4 树和森林 6.4.1 树的...
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 903
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 619
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 652
对于类类型，如果定义了接受。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 933
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
C++ 练习题四道 hv-LDM
m0_73379721的博客
05-14 358
4.文件操作 查找指定字符。1.判断两个日期间的天数。
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
JAVA树转二叉树，二叉树转森林，森林转二叉树
02-24
将JAVA树转换为二叉树可以通过使用递归调用的方法来实现。将二叉树转换为森林可以通过将根结点分离出来，然后将它的...将森林转换为二叉树可以通过将每个森林中的每棵树都连接起来，并将它们合并成一颗二叉树来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春野与望

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值