1、二叉树节点
代码:
//二叉树节点
#include<stdio.h>
#include <malloc.h>
#include <conio.h>
#include<iostream>
//
typedef int DataType;
typedef struct Node
{
DataType data;
struct Node *LChild;
struct Node *RChild;
}BinaryNode,*BinaryTree;
//用扩展先序遍历序列创建二叉树,如果是#当前树根置为空,否则申请一个新节点
void CreateBinaryTree(BinaryTree *bt)
{
char ch;
ch=getchar();
if(ch=='.')*bt=NULL;
else
{
*bt=(BinaryTree)malloc(sizeof(BinaryNode));
(*bt)->data=ch;
CreateBinaryTree(&((*bt)->LChild));
CreateBinaryTree(&((*bt)->RChild));
}
}
//访问根节点
void Visit(char ch)
{
printf("%c ",ch);
}
//先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针
void PreOrder(BinaryTree root)
{
if (root!=NULL)
{
Visit(root ->data); //访问根结点
PreOrder(root ->LChild); //先序遍历左子树
PreOrder(root ->RChild); //先序遍历右子树
}
}
void InOrder(BinaryTree root)
//中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针
{
if (root!=NULL)
{
InOrder(root ->LChild); //中序遍历左子树
Visit(root ->data); //访问根结点
InOrder(root ->RChild); //中序遍历右子树
}
}
//后序遍历二叉树,root为指向二叉树(或某一子树)根结点的指针
void PostOrder(BinaryTree root)
{
if(root!=NULL)
{
PostOrder(root ->LChild); //后序遍历左子树
PostOrder(root ->RChild); //后序遍历右子树
Visit(root ->data); //访问根结点
}
}
//后序遍历求二叉树的高度递归算法//
int PostTreeDepth(BinaryTree bt)
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->LChild); //求左子树的深度
hr=PostTreeDepth(bt->RChild); //求右子树的深度
max=hl>hr?hl:hr; //得到左、右子树深度较大者
return(max+1); //返回树的深度
}
else return(0); //如果是空树,则返回0
}
//按竖向树状打印的二叉树
void PrintTree(BinaryTree Boot,int nLayer)
{
int i;
if(Boot==NULL) return;
PrintTree(Boot->RChild,nLayer+1);
for(i=0;i<nLayer;i++)
printf(" ");
printf("%c\n",Boot->data);
PrintTree(Boot->LChild,nLayer+1);
}
//节点
int nodeCount(Node* T)
{ int nodecount=0;
while(T!=NULL)
{
return 1+nodeCount(T->LChild)+nodeCount(T->RChild);
}
return nodecount;
}
//叶节点
int leaf(Node* T)
{
int LeafCount=0;
if(T==NULL)
LeafCount=0;
else
if(T->LChild==NULL&&T->RChild==NULL)
LeafCount+=1;
else
LeafCount=leaf(T->LChild)+leaf(T->RChild);
return LeafCount;
}
//满节点
int fullleaf(Node* &T)
{if (NULL == T)
return 0;
return (T -> LChild != NULL && T -> RChild != NULL) + fullleaf (T -> LChild) + fullleaf (T -> RChild) ;
}
int main()
{
BinaryTree T;
int h;
int layer;
int treeleaf;
layer=0;
printf("请输入二叉树中的元素(以扩展先序遍历序列输入,其中.代表空子树):\n");
CreateBinaryTree(&T);
printf("先序遍历序列为:");
PreOrder(T);
printf("\n中序遍历序列为:");
InOrder(T);
printf("\n后序遍历序列为:");
PostOrder(T);
h=PostTreeDepth(T);
printf("\nThe depth of this tree is:%d\n",h);
PrintTree(T,layer);
int ch;
ch=nodeCount(T);
printf("\n该二叉树的节点数目为:%d\n",ch);
ch=leaf(T);
printf("\n该二叉树的叶节点数目为:%d\n",ch);
ch=fullleaf(T);
printf("\n该二叉树的满节点数目为:%d\n",ch);
return 0;
}
运行:
2、空指针
代码:
//空指针
/*设二叉树有n个节点,度为0的n0个,度为1的n1个,度为2的n2个,空链域只有度为1和度为0的有,一共有2n0+n1个空链域。
1.n=n0+n1+n2;
2.n=n1+2n2+1;
1式x2-2式即的结果*/
//二叉树节点
#include<stdio.h>
#include <malloc.h>
#include <conio.h>
#include<iostream>
typedef int DataType;
typedef struct BTNode
{
DataType data;
struct BTNode *lchild;
struct BTNode *rchild;
}BTNode,*BinaryTree;
//用扩展先序遍历序列创建二叉树,如果是#当前树根置为空,否则申请一个新节点
void CreateBinaryTree(BinaryTree *bt)
{
char ch;
ch=getchar();
if(ch=='.')*bt=NULL;
else
{
*bt=(BinaryTree)malloc(sizeof(BTNode));
(*bt)->data=ch;
CreateBinaryTree(&((*bt)->lchild));
CreateBinaryTree(&((*bt)->rchild));
}
}
//求二叉树中度为0的节点个数
int NumberOfZeroDegree(BTNode *T)
{
int i=0;
if(NULL != T)
{
if(NULL==T->lchild && NULL==T->rchild)
{
i=1;
}
else
{
i= NumberOfZeroDegree(T->lchild)+NumberOfZeroDegree(T->rchild);
}
}
return i;
}
//求二叉树中度为1的节点个数
int NumberOfOneDegree(BTNode *T)
{
int i=0;
if(NULL != T)
{
if((NULL!=T->lchild && NULL==T->rchild) ||(NULL!=T->rchild && NULL ==T->lchild))
{
i=1+NumberOfOneDegree(T->lchild)+NumberOfOneDegree(T->rchild);
}
else
{
i=NumberOfOneDegree(T->lchild)+NumberOfOneDegree(T->rchild);
}
}
return i;
}
//求二叉树中度为2的节点个数
int NumberOfTwoDegree(BTNode *T)
{
int i=0;
if(NULL != T)
{
if((NULL!=T->lchild)&&(NULL!=T->rchild))
i=1+NumberOfTwoDegree(T->lchild)+NumberOfTwoDegree(T->rchild);
else
i=NumberOfTwoDegree(T->lchild)+NumberOfTwoDegree(T->rchild);
}
return i;
}
//1.n=n0+n1+n2;
int NumberAllNodes1(BTNode *T)
{
return NumberOfZeroDegree(T)+NumberOfOneDegree(T)+NumberOfTwoDegree(T);
}
//2.n=n1+2n2+1;
int NumberAllNodes2(BTNode *T)
{
return 2*NumberOfOneDegree(T)+NumberOfTwoDegree(T)+1;
}
//求 nullptr的值
int Numberofnullptr(BTNode *T)
{
return NumberAllNodes1(T)-1;
}
int main()
{
BinaryTree T;
printf("请输入二叉树中的元素(以扩展先序遍历序列输入,其中.代表空子树):\n");
CreateBinaryTree(&T);
int ch;
ch=NumberOfZeroDegree(T);
printf("\n该二叉树度为0的节点数目为:%d\n",ch);
ch=NumberOfOneDegree(T);
printf("\n该二叉树度为1的叶节点数目为:%d\n",ch);
ch=NumberOfTwoDegree(T);
printf("\n该二叉树度为2的满节点数目为:%d\n",ch);
ch=NumberAllNodes1(T);
//ch=NumberAllNodes2(T);
printf("\n该二叉树的节点数目为:%d\n",ch);
ch=Numberofnullptr(T);
printf("\n该二叉树的空指针数目为:%d\n",ch);
return 0;
}
运行:
3、删除叶节点
代码:
#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
struct BiNode
{
char data;
BiNode *lchild, *rchild;
};
class BiTree
{
public:
BiTree( );
BiNode * Getroot();
int Delete(BiNode *root);
void LeverOrder(BiNode *root);
private:
BiNode *root;
BiNode *Creat( );
};
BiTree::BiTree( )
{
this->root = Creat( );
}
BiNode *BiTree::Getroot( )
{
return root;
}
int BiTree::Delete(BiNode *root)
{
if(root==NULL)
return (int)NULL;
else
{
if(!root->lchild && !root->rchild)//判断是否为叶子
root->data ='#';//将节点值置空
Delete(root->lchild);//并删除当前节点的左右孩子
Delete(root->rchild);
}
return 0;
}
void BiTree::LeverOrder(BiNode *root)//层序输出
{
const int MaxSize = 100;
int front = 0;
int rear = 0;
BiNode* Q[MaxSize];
BiNode* q;
if (root == NULL) return;
else
{
Q[rear++] = root;
while (front != rear)
{
q = Q[front++];
if(q->data!='#')
cout<<q->data<<" ";
if (q->lchild != NULL) Q[rear++] = q->lchild;
if (q->rchild != NULL) Q[rear++] = q->rchild;
}
}
}
BiNode* BiTree ::Creat( )
{
BiNode * root;
char ch;
cin>>ch;
if (ch == '#')
root = NULL;
else
{
root = new BiNode;
root->data=ch;
root->lchild = Creat( );
root->rchild = Creat( );
}
return root;
}
//判断是否为叶子,然后删除,最后层序输出就行了
int main()
{
BiTree bt;
BiNode *root = bt.Getroot( );
bt.Delete(root);
bt.LeverOrder(root);
return 0;
}
运行:
4、最大节点数
代码:
//最大节点数,则该二叉树为满二叉树
#include<stdio.h>
#include <conio.h>
#include<iostream>
using namespace std;
typedef int DataType;
typedef struct Node
{
DataType data;
struct Node *lChild;
struct Node *rChild;
}BinTreeNode,*BinaryTree;
//后序遍历求二叉树的高度递归算法
int PostTreeDepth(BinaryTree bt)
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt->lChild); //求左子树的深度
hr=PostTreeDepth(bt->rChild); //求右子树的深度
max=hl>hr?hl:hr; //得到左、右子树深度较大者
return(max+1); //返回树的深度
}
else return(0); //如果是空树,则返回0
}
template<class T>
int BinaryTree<T>::twoDegree(BinTreeNode<T>* bt)
{
//子树不空
if(bt!=NULL)
{
//如果左右子树都不空
if(bt->lChild!=NULL
&& bt->rChild!=NULL)
//递归统计左右子树,并返回两者的和,并加1
return 1+twoDegree(bt->lChild)
+twoDegree(bt->rChild);
else
return 0;
}
else
return 0;
}
int main()
{
BinaryTree T;
int h;
int n;
h=PostTreeDepth(T);
printf("\nThe depth of this tree is:%d\n",h);
n=BinaryTree(T);
printf("\nThe jiedian of this tree is:%d\n",n);
return 0;
}