数据结构二叉树的基本操作~~~~
试试，挺好的！还有菜单！
#include
using namespace std;
struct Node
{
char data;
Node *left;
Node *right;
}*BiTree;
class Tree
{
public:
void Setroot();//设置二叉树的根节点
void CreateTree(Node*); //先序递归创建二叉树函数
void DeleteTree(Node*);//二叉树的销毁函数
void PostOrderTraverse(Node*);//后续递归遍历二叉树函数
void InOrderTraverse(Node*);//中序非递归遍历二叉树函数
void LevelOrder(Node *);//层次遍历二叉树函数
void leaves1(Node *);//输出二叉树的叶子节点函数
void leaves2(Node *);//输出二叉树的二叉节点函数
void leaves3(Node *);//输出二叉树的一叉节点函数
//int Showleaves(Node *);//输出二叉树的叶子节点个数函数
int Depthoftree(Node *);//计算二叉树的深度函数
bool Iscomplete(Node *);//判断二叉树是否为完全二叉树函数
bool Isp(Node *);//判断二叉树是否已初始化
~Tree(){DeleteTree(root);}//Tree的析构函数
static Node *root;//定义二叉树的根节点为静态变量
};
Node* Tree::root=0;//初始化二叉树的根节点
void Tree::Setroot()//设置二叉树的根节点
{
cout<<"输入树的根节点(如果为空输入#):";
root=new Node;
cin>>root->data;
CreateTree(root);//调用CreateTree()函数生成二叉树
}
bool Tree::Isp (Node *p=root)//判断二叉树是否已存在
{
if(p){return true;}
else return false;
}
void Tree::CreateTree(Node *p)//先序递归创建二叉树
{
if(p)
{
char x,y; Node *q;
coutdata<<"的左孩子和右孩子:";
cin>>x>>y;
if(x=='#')
p->left=0;
else
{
q=new Node;
q->data=x;
p->left=q;
}
if(y=='#')
p->right=0;
else
{
q=new Node;
q->data=y;
p->right=q;
}
CreateTree(p->left);
CreateTree(p->right);
}
}
void Tree::InOrderTraverse(Node *p=root)//中序非递归遍历二叉树
{
Node *q;
Node *stack[100];
int top=0;
q=p;
if(p)
{
while(q||top!=0)
{
while(q)
{
stack[top++]=q;
q=q->left ;
}
q=stack[--top];
coutdata <<" ";
q=q->right ;
}
}
else{cout<<"请先建立二叉树!!!"<<endl;}
}
void Tree::LevelOrder(Node *p=root)//层次遍历二叉树
{
Node stack[100];//设置堆栈
int front=0,rear=0;
Node q;
if(p)
{
stack[rear]=*p;
rear=(rear+1)%100;
}
while(front!=rear)
{
p=&stack[front];
front=(front+1)%100;
coutdata<<" ";
if(p->left )
{
stack[rear]=*p->left ;
rear=(rear+1)%100;
}
if(p->right )
{
stack[rear]=*p->right ;
rear=(rear+1)%100;
}
}
}
void Tree::PostOrderTraverse(Node *p=root)//后续递归遍历二叉树
{
if(p)
{
PostOrderTraverse(p->left);
PostOrderTraverse(p->right);
coutdata<<" ";
}
}
void Tree::DeleteTree(Node *p=root)//销毁二叉树
{
if(p)
{
DeleteTree(p->left);
DeleteTree(p->right);
delete p;
}
}
int Tree::Depthoftree (Node *p=root)//计算二叉树的深度
{
if(p)
{
int h1=Depthoftree(p->left );
int h2=Depthoftree(p->right );
return(1+(h1>h2?h1:h2));
}
else return 0;
}
/*int Tree::Showleaves (Node *p=root)//计算二叉树的叶子结点个数
{
int rnum,lnum;
int i=0;
if(p)
{
if((p->left ==NULL)||(p->right==NULL))
{
return 1;
}
else
{
rnum=Showleaves(p->left);
lnum=Showleaves(p->right);
return rnum+lnum;
}
}
else return 0;
}*/
void Tree::leaves1 (Node *p=root)//输出二叉树的叶子节点
{
if(p)
{
if((p->left ==NULL)&&(p->right==NULL))
{
coutdata <<" ";
}
leaves1(p->left );
leaves1(p->right );
}
}
void Tree::leaves2 (Node *p=root)//输出二叉树的二叉节点
{
if(p)
{
if((p->left !=NULL)&&(p->right!=NULL))
{
coutdata <<" ";
}
leaves2(p->left );
leaves2(p->right );
}
}
void Tree::leaves3(Node *p=root)//输出二叉树的一叉节点
{
if(p)
{
if(((p->left !=NULL)&&(p->right==NULL))||((p->left==NULL)&&(p->right!=NULL)))
{
coutdata <<" ";
}
leaves3(p->left );
leaves3(p->right );
}
}
bool Tree::Iscomplete(Node *p=root)//判断二叉树是否为完全二叉树
{
Node stack[100],*q,*r;/*定义队列*/
int front=0,rear=0;
if(p)
{
stack[rear]=*p;
rear=(rear+1)%100;
}
/*此while的作用是在根节点在队内的初始情况下开始*/
/*按层次遍历二叉树*/
/*只遍历左右子树都有的节点 while结束时 p指向第一个例外节点*/
while(rear!=front)
{
q=&stack[front];
front=(front+1)%100;
if((rear+1)%100!=front&&p->left!=NULL&&p->right!=NULL) /*当队不满，*/
{
stack[rear]=*p->left;
rear=(rear+1)%100;
stack[rear]=*p->right;
rear=(rear+1)%100;
}
else break;
}
/*经前面的while，p肯定指向第一个没有双子的节点*/
/*此时又分四种情况*/
if(p->left==NULL&&p->right!=NULL)return false; /*第一种:有右无左 肯定不是完全二叉树*/
else if(p->left!=NULL&&(p->left->left!=NULL||p->left->right!=NULL))
return false; /*第二种:有左无右但左子树还有子树 排除*/
/*第三种:有左无右 左也无子,*/
/*但在继续按层次遍历过程中*/
/*发现后来的某个节点有子树,排除*/
else
{
while(rear!=front)
{
q=&stack[front];
front=(front+1)%100;
if(p->left!=NULL||p->right!=NULL) return false;
}
} /*经过层层筛选,剩下的就是真金*/
//return true;
}
void main()
{
int /*leave=0,*/depth=0;
bool key,t=true;//key接受Isp()的返回值；t接受Iscomplete()的返回值
Tree tree;
int select=0;
while(select!=8)
{
cout<<endl;
cout<<" ————————————————————————"<<endl;
cout<<" ╭————————请选择操作号————————╮"<<endl;
cout<<" ∣ ∣"<<endl;
cout<<" ├——————————————————————┤"<<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<<" ╰——————————————————————╯"<<endl;
cout<<" ————————————————————————"<<endl;
cout<<" 请选择您要服务的类别: " ;
cin>>select;
switch(select)
{
case 1:
tree.DeleteTree ();
tree.Setroot (); break;
case 2:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树******!!!"<<endl;break;}
cout<<"***************************"<<endl;
cout<<"树的后序遍历结果为:";
tree.PostOrderTraverse ();
cout<<endl<<"***************************"<<endl;break;
case 3:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树******!!!"<<endl;break;}
cout<<"***************************"<<endl;
cout<<"树的中序遍历结果为:";
tree.InOrderTraverse ();
cout<<endl<<"***************************"<<endl;break;
case 4:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树******!!!"<<endl;break;}
cout<<"***************************"<<endl;
cout<<"树的层次遍历结果为:";
tree.LevelOrder ();
cout<<endl<<"***************************"<<endl;break;
case 5:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树!!!"<<endl;break;}
/*leave=tree.Showleaves ();
cout<<"***************************"<<endl;
cout<<"叶子结点数为：";
cout<<leave<<endl;*/
cout<<"叶结点为：";
tree.leaves1 ();
cout<<endl;
cout<<"二叉结点为：";
tree.leaves2 ();
cout<<endl;
cout<<"一叉结点为：";
tree.leaves3 ();
cout<<endl<<"***************************"<<endl;break;
case 6:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树*******!!!"<<endl;break;}
depth=tree.Depthoftree();
cout<<"***************************"<<endl;
cout<<"树的深度为："<<depth<<endl;
cout<<endl<<"***************************"<<endl;break;
case 7:
key=tree.Isp ();
if(!key){cout<<"*****请先建立二叉树******!!!"<<endl;break;}
cout<<"***************************"<<endl;
t=tree.Iscomplete() ;
if(t){cout<<"是完全二叉树！"<<endl;}
else{cout<<"不是完全二叉树！"<<endl;}
cout<<endl<<"***************************"<<endl;break;
case 8:break;
default:
cout<<"警告!命令错误,请重新输入!!!"<<endl;
}
if(select == 8)
cout<<"系统已经退出!"<<endl;
break;
}
exit(1);
#include
#include
#include
typedef struct BiTNode{
int data;
struct BiTNode *lchild ,*rchild;
} *BiTree;
void CreateBiTree(BiTree &T );
void Pre(BiTree p);
void PreOrderTraverse(BiTree p);
void In(BiTree p);
void InOrderTraverse(BiTree p);
void Post(BiTree T);
void Menu(BiTree &T);
int main(){
BiTree T;
T = (BiTNode *)malloc(sizeof(BiTNode));
T -> lchild = NULL;
T -> rchild = NULL;
Menu(T);
return 0;
}
void Menu(BiTree &T){
int i;
for( ; ; ){
printf("Menu:
");
printf("______________________________
");
printf("******************************
");
printf("*1.构建二叉树 *
");
printf("*2.先序遍历二叉树 *
");
printf("*3.中序遍历 *
");
printf("*4.后序遍历 *
");
printf("******************************
");
printf("请输入操作序号：");
scanf("%d", &i);
printf("
");
switch(i){
case 1: CreateBiTree(T); break;
case 2: printf("先序递归遍历为：");
Pre(T);
printf("
");
printf("先序非递归遍历为：");
PreOrderTraverse(T);
break;
case 3: printf("中序递归遍历为：");
In(T);
printf("
");
printf("中序非递归遍历为：");
InOrderTraverse(T);
break;
case 4: printf("后序递归遍历为：");
Post(T);
printf("
");
break;
default: printf("输入有误!
");
}
}
}
void CreateBiTree(BiTree &p){ //注意：‘&’???
int e;
printf("请输入数据,无左右孩子以0结束:");
scanf("%d",&e);
if(e == 0)p = NULL;
else{
p = (BiTNode *)malloc(sizeof(BiTNode));
p -> data = e;
CreateBiTree(p->lchild);
CreateBiTree(p->rchild);
}
}
/*用会的检验初始化是否正确!!!*/
void Pre(BiTree p){
if(p)
{printf("%d",p->data);
Pre(p->lchild);
Pre(p->rchild);
}
}
void In(BiTree p){
if(p){
In(p->lchild);
printf("%d",p->data);
In(p->rchild);
}
}
void Post(BiTree p){
if(p){
Post(p->lchild);
Post(p->rchild);
printf("%d",p->data);
}
}
void PreOrderTraverse(BiTree p){
int top = -1;
BiTree a[20];
while(top != -1||p != NULL){
while(p != NULL) {
printf("%d", p -> data);
top++;
a[top] = p;
p = p -> lchild;
}
if(top != -1){
p = a[top];
top --;
p = p -> rchild;
}
}
printf("
");
}
void InOrderTraverse(BiTree p){
BiTree a[20];//存p指向的首地址
int top = -1;
while(p!=NULL || top != -1){
while(p!=NULL){
top++;
a[top] = p;
p=p->lchild;
}
if(top!=-1){
p=a[top];
top--;
printf("%d",p->data);
p=p->rchild;
}
}
printf("
");
}
我们刚实训完，后序非递归我也不会，c学得也不咋样
1．以二叉链表表示二叉树，建立一棵二叉树；
2．输出二叉树的前序遍历结果；
3．输出二叉树的中序遍历结果；
4．输出二叉树的后序遍历结果；
5．统计二叉树的叶结点个数；
6．统计二叉树的结点个数；
7．计算二叉树的深度。
8．交换二叉树每个结点的左孩子和右孩子；
#include <malloc.h>
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#define OK 1
#define NULL 0
#define FALSE 0
typedef struct BiTNode{ //定义链式二叉树结构体
char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
BiTree T;
char ch;
int flag=0;
int createBiTree(BiTree &T){
//按先序输入二叉树中结点的值（一个字符），空格表示空树
ch=getchar();
if(ch==' ')T=NULL; //表示空树
else if(ch==10)flag=1; //结点信息输入错误则返回0
else {
T=(BiTNode*)malloc(sizeof(BiTree));
if(!T)exit(1);//空间分配不成功则退出
T->data=ch; //生成根结点
createBiTree(T->lchild); //生成左子树
createBiTree(T->rchild); //生成右子树
}//else
return OK;
}//createBiTree
int PreOrderTraverse(BiTree T){ //先序遍历二叉树的递归算法
if(T){
printf("%c",T->data); //访问根结点
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}//if
return OK;
}
int InOrderTraverse(BiTree T){ //中序
if(T){
InOrderTraverse(T->lchild);
printf("%c",T->data); //访问根结点
InOrderTraverse(T->rchild);
}//if
return OK;
}
int PostOrderTraverse(BiTree T){ // 后序
if(T){
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c",T->data); //访问根结点
}
return OK;
}
int NodeCount(BiTree T){ //
if(T==NULL) return 0;// 如果是空树，则结点个数为0
else return 1+NodeCount(T->lchild)+NodeCount(T->rchild);
//否则结点个数为1+左子树的结点个数+右子树的结点个数
}
int LeafNodeCount(BiTree T ){
if(!T)return 0; //如果是空树，则叶子个数为0;
else if(LeafNodeCount(T->lchild)+LeafNodeCount(T->rchild)==0)return 1;//如果是叶子结点，则叶子结点个数为1
else return LeafNodeCount(T->lchild)+LeafNodeCount(T->rchild);
//否则叶结点个数为左子树的叶结点个数+右子树的叶结点个数
}
int Depth(BiTree T){//计算二叉树的深度
int m,n;
if(T==NULL )return 0;//如果是空树，则深度为0
else {
m=Depth(T->lchild);//计算左子树的深度记为m
n=Depth(T->rchild);//计算右左子树的深度记为n
if(m>n) return(m+1);//二叉树的深度为m 与n的较大者加1
else return (n+1);
}
}
void Exchange1(BiTree T)
{
BiTree temp;
if(T)
{
Exchange1(T->lchild);
Exchange1(T->rchild);
temp=T->lchild;
T->lchild=T->rchild;
T->rchild=temp;
}
}
void main(){
int no,out=1;
char choose;
//*****************************主界面**********************************
while(out){
system("cls");
printf("\n这是实验2的程序，请按照说明使用：\n");
printf("1．以二叉链表表示二叉树，建立一棵二叉树，请输入1");
printf("\n2．输出二叉树的前序遍历结果，请输入2");
printf("\n3．输出二叉树的中序遍历结果，请输入3");
printf("\n4．输出二叉树的后序遍历结果请输入4");
printf("\n5．统计二叉树的结点个数，请输入5");
printf("\n6．统计二叉树的叶结点个数，请输入6");
printf("\n7．计算二叉树的深度，请输入7");
printf("\n8. 交换二叉树的左右孩子，请输入8");
printf("\n9．退出，请输入其他\n");
//********************处理输入的选项************************************
choose=getch();
switch(choose){
case '1':
system("cls");
printf("\n请输入二叉链表各结点信息建立二叉树，空树用空格表示：\n");
if(createBiTree(T)==0||flag==1){ //结点输入错误！
printf("输入错误，请重新输入结点信息!\n");
getch();break;}
else
printf("输入完毕！");//成功建立二叉链表
getch();break;
case '2':
printf("\n先序遍历的结果是：");
PreOrderTraverse(T);
getch();break;
case '3':
printf("\n中序遍历的结果是：");
InOrderTraverse(T);
getch();break;
case '4':
printf("\n后序遍历的结果是：");
PostOrderTraverse(T);
getch();break;
case '5':
no=NodeCount(T);
printf("\n总结点个数为:%d\n",no);
getch();break;
case '6':
printf("\n叶子结点的个数为:%d\n",LeafNodeCount(T));
getch();break;
case '7':
printf("\n二叉树深度为：%d\n",Depth(T));
getch();break;
case '8':
printf("\n交换后的结果为：");
Exchange1(T);
PostOrderTraverse(T);
getch();break;
default :
printf("\n你输入的是:其他\n");
getch();
out=0;
} //end switch
}//end of while
system("cls");
printf("\n\n\t\t欢迎使用，再见！");
}
碉堡了！
二叉树的基本操作 C语言实现/*程序实现内容
1．采用二叉树链表作为存储结构，建立二叉树；
2．对二叉树分别按先、中、后序以及按层次遍历，输出相应的访问序列；
3．计算二叉树的深度，统计所有叶子结点总数及树中包含的结点总数。*/
#include"stdio.h"
#include"string.h"
#include"malloc.h"
#define Max 20 //结点的最大个数
typedef struct node{
char data;
struct node *lchild,*rchild;
}BinTNode; //自定义二叉树的结点类型
typedef BinTNode *BinTree; //定义二叉树的指针
int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数
//基于先序遍历算法创建二叉树
//要求输入先序序列，其中加入虚结点“#”以示空指针的位置
BinTree CreatBinTree(void)
{
BinTree T;
char ch;
if((ch=getchar())=='#')
return(NULL); //读入#，返回空指针
else{
T=(BinTNode *)malloc(sizeof(BinTNode));//生成结点
T->data=ch;
T->lchild=CreatBinTree(); //构造左子树
T->rchild=CreatBinTree(); //构造右子树
return(T);
}
}
//DLR 先序遍历
void Preorder(BinTree T)
{
if(T) {
printf("%c",T->data); //访问结点
Preorder(T->lchild); //先序遍历左子树
Preorder(T->rchild); //先序遍历右子树
}
}
//LDR 中序遍历
void Inorder(BinTree T)
{
if(T) {
Inorder(T->lchild); //中序遍历左子树
printf("%c",T->data); //访问结点
Inorder(T->rchild); //中序遍历右子树
}
}
//LRD 后序遍历
void Postorder(BinTree T)
{
if(T) {
Postorder(T->lchild); //后序遍历左子树
Postorder(T->rchild); //后序遍历右子树
printf("%c",T->data); //访问结点
}
}
//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法
int TreeDepth(BinTree T)
{
int hl,hr,max;
if(T){
hl=TreeDepth(T->lchild); //求左深度
hr=TreeDepth(T->rchild); //求右深度
max=hl>hr? hl:hr; //取左右深度的最大值
NodeNum=NodeNum+1; //求结点数
if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。
return(max+1);
}
else return(0);
}
//利用“先进先出”（FIFO）队列，按层次遍历二叉树
void Levelorder(BinTree T)
{
int front=0,rear=1;
BinTNode *cq[Max],*p; //定义结点的指针数组cq
cq[1]=T; //根入队
while(front!=rear)
{
front=(front+1)%NodeNum;
p=cq[front]; //出队
printf("%c",p->data); //出队，输出结点的值
if(p->lchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->lchild; //左子树入队
}
if(p->rchild!=NULL){
rear=(rear+1)%NodeNum;
cq[rear]=p->rchild; //右子树入队
}
}
}
//主函数
main()
{
BinTree root;
int i,depth;
printf("\n");
printf("Creat Bin_Tree; Input preorder:"); //输入完全二叉树的先序序列，
// 用#代表虚结点，如ABD###CE##F##
root=CreatBinTree(); //创建二叉树，返回根结点
do { //从菜单中选择遍历方式，输入序号。
printf("\t********** select ************\n");
printf("\t1: Preorder Traversal\n");
printf("\t2: Iorder Traversal\n");
printf("\t3: Postorder traversal\n");
printf("\t4: PostTreeDepth,Node number,Leaf number\n");
printf("\t5: Level Depth\n"); //按层次遍历之前，先选择4，求出该树的结点数。
printf("\t0: Exit\n");
printf("\t*******************************\n");
scanf("%d",&i); //输入菜单序号（0-5）
switch (i){
case 1: printf("Print Bin_tree Preorder: ");
Preorder(root); //先序遍历
break;
case 2: printf("Print Bin_Tree Inorder: ");
Inorder(root); //中序遍历
break;
case 3: printf("Print Bin_Tree Postorder: ");
Postorder(root); //后序遍历
break;
case 4: depth=TreeDepth(root); //求树的深度及叶子数
printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);
printf(" BinTree Leaf number=%d",leaf);
break;
case 5: printf("LevePrint Bin_Tree: ");
Levelorder(root); //按层次遍历
break;
default: exit (1);
}
printf("\n");
} while(i!=0);
二叉树遍历算法规律是什么?
答：遍历序列是指沿着某条搜索路线访问序列中的元素，不同的遍历方式，其访问序列中元素的顺序是不一样的，并且和序列的有关性质有关，例如一个给定序列的子序列是从给定序列中去除一些元素，而不改变其他元素之间相对位置而得到的。在数据结构中，应用遍历序列最多的结构是树和图。
50分急求!!数据结构课程设计,c链表的基本操作和二叉树的几种遍历!!!
答：要求:利用链表的插入运算建立线性链表,然后实现链表的查找、插入、删除、计数、输出、排序、逆置等运算(查找、插入、删除、查找、计数、输出、排序、逆置要单独写成函数),并能在屏幕上输出操作前后的结果。1.对任意给定的二叉树(顶点数自定)建立它的二叉链表存储结构,并实现二叉树的先序、中序、后序三种遍历,输出三...
什么是树的层次遍历 要求通俗易懂
答：其思想为：用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。在进行层次遍历的时候，设置一个队列结构，遍历从二叉树的根节点开始，首先将根节点指针入队列，然后从队头取出一个元素，每取一个元素，执行下面两个操作：1、访问该元素所指向的节点。2、若该元素所指节点的左右孩子节点非空，则将...
二叉树结点是什么意思?
答：这样的结构可以用来实现各种数据结构或算法。在二叉树中，每个结点代表了一个唯一的元素，它可以存储一些有用的信息，比如键值对、字符串等。通过结点间的链接关系，我们可以访问整个树中的元素。在许多算法中，我们需要遍历树并检查每个结点，以便找到特定的元素或执行特定的操作。因此，结点在二叉树中发挥...
数据结构主要学什么内容?
答：（1）线性表的定义和基本操作 （2）线性表的实现 1、顺序存储结构 2、链式存储结构 3、线性表的应用 二、栈、队列和数组 （一）栈和队列的基本概念 （二）栈和队列的顺序存储结构 （三）栈和队列的链式存储结构 （四）栈和队列的应用 （五）特殊矩阵的压缩存储 三、树与二叉树 （一）树的概念...
数据结构的问题 求步骤和思路
答：二叉树的前序序列是树根在前面，中序序列里面树根在中间。逻辑是重复的按照，先通过前序确定树根，再通过中序确定左右子树。前序 ABDGCEF 中 DGBAECF。 可以看出 树根是，A。推出左树的前序BDG 中序 DGB；右树的前序是CEF 中序是ECF；接着分别找出左树的树根和左右子树，右树的树根和左右...
数据结构讲的是什么
答：(一)线性表的定义和基本操作 (二) 线性表的实现 1. 顺序存储结构 2. 链式存储结构 3. 线性表的应用 二、栈、队列和数组 (一)栈和队列的基本概念 (二)栈和队列的顺序存储结构 (三)栈和队列的链式存储结构 (四)栈和队列的应用 (五)特殊矩阵的压缩存储 三、树与二叉树 (一)树的概念...
二叉排序树定义
答：二叉排序树通常采用二叉链表作为存储结构。中序遍历二叉排序树可得到一个依据关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即是对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个...
怎么计算二叉树高度?
答：分析二叉树的深度（高度）和它的左、右子树深度之间的关系。从二叉树深度的定义可知，二叉树的深度应为其左、右子树深度的最大值加1。由此，需先分别求得左、右子树的深度，算法中“访问结点”的操作为：求得左、右子树深度的最大值，然后加 1 。int Depth (BiTree T ){ // 返回二叉树的深度...
数据结构主要学什么内容
答：《数据结构》主要学习线性表、栈的队列和数组、树与二叉树、图。详细内容如下：1、线性表：线性表的定义和基本操作、线性表的实现、顺序存储结构；2、栈的队列和数组：栈和队列的基本概念、栈和队列的顺序存储结构、栈和队列的链式存储结构、栈和队列的应用、特殊矩阵的压缩存储；3、树与二叉树：树的...
