#include "string.h" 
 #include "stdio.h" 
 #include "malloc.h"
 
typedef struct BiTNode{
     char data;   /*结点的数据域*/
     struct BiTNode *lchild , *rchild;  /*指向左孩子和右孩子*/
 } BiTNode , *BiTree;
 
void CreatBiTree(BiTree *T){
     char c;
     scanf("%c",&c);
     if(c == ' ') *T = NULL;
     else{
        *T = (BiTNode * )malloc(sizeof(BiTNode));  /*创建根结点*/
         (*T)->data = c;    /*向根结点中输入数据*/
         CreatBiTree(&((*T)->lchild));  /*递归地创建左子树*/
         CreatBiTree(&((*T)->rchild));  /*递归地创建右子树*/
     }
 }
 
void getLeavesConut (BiTree T,int *count){
     if(T!=NULL && T->lchild==NULL && T->rchild==NULL){   /*访问到叶结点*/
         *count = *count + 1;
     }
     if(T){
         getLeavesConut (T->lchild,count);  /*先序遍历T的左子树*/
         getLeavesConut (T->rchild,count);  /*先序遍历T的右子数*/
     }
 }
 
int getBiTreeLeavesCount(BiTree T) {
     int count = 0;                /*在主调函数中定义变量count，初始值为0*/
     getLeavesConut(T, &count);    /*调用递归函数getLeavesConut计算叶子结点个数*/
     return count;                /*返回叶子结点个数*/
 }
 
main()
 {
    BiTree T = NULL;                /*初始化T */
    int count = 0;
    printf("Input some characters to create a binary tree \n");
    CreatBiTree(&T);                /*创建一棵二叉树*/
    getLeavesConut (T,&count);    /*计算二叉树中叶子结点的个数 */
    printf("The number of leaves of BTree are %d\n",count);
    getchar();
    getchar();
 }

1、已知完全二叉树具有967个结点，则其叶子结点个数为：
 
详解：
 
首先明确一点该二叉树是一棵二叉树，那可以使用二叉树的一些性质。
 
从第一层开始计算每层的节点个数：1，2,4,8,16,32,64,128,256,512,1024...
 
将前9层的结点数量全部加起来有511个，如果加上第十层1024，则超过967，所以该完全二叉树肯定是有十层的，所以叶子结点分布在第9层和第10层，且第10层全部都是叶子结点。
 
设第9层的叶子个数为b，第9层的分支结点个数为a；
 
由于是完全二叉树，又该树有10层，所以第9层肯定有2^(9-1) = 256个结点，则有关系式：
 
a + b = 256    ---------------(1)
 
又第9层的分支结点个数为a,那么第10层的叶子个数为2*a, 或者2*a-1 个，对于这两种情况，可以根据总的结点个数来确定，因为967是一个奇数，又第1层根节点只有一个，总的结点个数减去1，则为966，是一个偶数，所以第10层的叶子个数肯定为2*a个。
 
已知前9层共有1+2+4+8+16+32+64+128+256 = 511个结点，第10层有2*a个结点，所以结点总数为前9层的总数加上第10层的个数，则有关系式：
 
2*a + 511 = 967  ---------------(2)
 
结合关系式（1）（2），可解得a = 228, b = 28，
 
叶子结点总数为第9层的叶子数加上第10层的叶子数：b + 2*a = 28 + 2 * 228 = 484。
 
 
 
 
 
2、在一棵度为4的树T中，如有20个度为4的结点，10个度为3的结点，1个度为2的结点，10个度为1的结点，则树T中的叶子结点个数为：
 
解：设结点总数为n,叶子结点个数为m。
 
则结点总数: n = 20 + 10 + 1 + 10 + m        ---------------(1)
 
还有一个关系式是关于结点总数和总度数的。
 
假如将“度”理解为一根绳子，对于每一棵树，我们都很清楚，每一个结点都是由一个度牵引着的，除了根节点这个特殊结点没有被度牵引。所以，总结点数是总的度数加上根节点的数目，而根节点只有一个，所以总结点数 = 总的度数 + 1，由此，可以得到下面的结点总数和度总数的关系式：
 
n = 20*4 + 10*3 + 1*2 + 10*1 + m*0  + 1      ---------------(2)
 
联合关系式（1）（2），可解得m = 82。
 
 
 
3、一棵度为3的树中，有3度结点100个，有2度结点200个，则叶子结点个数为：
 
解：虽然这棵树不是二叉树，但是有些性质也是适用的。其中，最重要的一个性质是结点总数和总度数的关系。
 
设1度结点共有a个，叶子结点共有b个，总的结点个数为n,则有以下关系式：
 
n = 100 + 200 + a + b
 
n = 3 * 100 + 2 * 200 + 1 * a + 0 * b + 1
 
联合以上两个关系式可以解得 b = 401，即叶子个数为401个。
 
 
 
总结：
 
大部分关于二叉树的计算问题，只要仅仅抓住二叉树和树的性质，基本上都能很快解决。
 
所以对于二叉树的性质要非常熟悉，不仅仅要知道性质的内容，也要知道性质的推倒过程。

二叉树叶子结点的计算
 
//统计叶子结点的数目
int LeafNum(BiTree T) {
	if (!T) {
		return 0;
	} else if (!T->lchild && !T->rchild) {
		return 1;
	} else {
		return LeafNum(T->lchild) + LeafNum(T->rchild);
	}
}

 
二叉树非叶子节点的计算
 
//统计非叶子结点的数目
int NotLeafNum(BiTree T) {
	if (!T) {
		return 0;
	} else if (!T->lchild && !T->rchild) {
		return 0;
	} else {
		return NotLeafNum(T->lchild) + NotLeafNum(T->rchild) + 1;
	}
}

 
二叉树深度的计算
 
//计算二叉树的深度
int BiTreeDeepth(BiTree T) {
	if (!T) {
		return 0;
	}
	return BiTreeDeepth(T->lchild) > BiTreeDeepth(T->rchild) ?
		1 + BiTreeDeepth(T->lchild) : 1 + BiTreeDeepth(T->rchild);
}

 
测试
 
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <windows.h>
//定义一个二叉树
typedef struct Node {
	char data;
	struct Node* lchild;
	struct Node* rchild;
}BitNode, *BiTree;
//创建二叉树
void CreateBiTree(BiTree* T) {
	char ch = 0;
	scanf("%c", &ch);
	if (ch == ' ') {
		*T = NULL;
	} else {
		*T = (BiTree)malloc(sizeof(BitNode));
		if (!(*T)) {
			exit(-1);
		}
		(*T)->data = ch;
		CreateBiTree(&((*T)->lchild));
		CreateBiTree(&((*T)->rchild));
	}
}
//遍历二叉树
void PreOrderTraverse(BiTree T) {
	if (T) {
		printf("%2c", T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}
void Destroy(BiTree* T) {
	if (*T) {
		if ((*T)->lchild) {
			Destroy(&((*T)->lchild));
		}
		if ((*T)->rchild) {
			Destroy(&((*T)->rchild));
		}
		free(*T);
		*T = NULL;
	}
}
//统计叶子结点的数目
int LeafNum(BiTree T) {
	if (!T) {
		return 0;
	} else if (!T->lchild && !T->rchild) {
		return 1;
	} else {
		return LeafNum(T->lchild) + LeafNum(T->rchild);
	}
}
//统计非叶子结点的数目
int NotLeafNum(BiTree T) {
	if (!T) {
		return 0;
	} else if (!T->lchild && !T->rchild) {
		return 0;
	} else {
		return NotLeafNum(T->lchild) + NotLeafNum(T->rchild) + 1;
	}
}
//计算二叉树的深度
int BiTreeDeepth(BiTree T) {
	if (!T) {
		return 0;
	}
	return BiTreeDeepth(T->lchild) > BiTreeDeepth(T->rchild) ?
		1 + BiTreeDeepth(T->lchild) : 1 + BiTreeDeepth(T->rchild);
}
int main() {
	BiTree t1;
	CreateBiTree(&t1);
	printf("**********************\n");
	PreOrderTraverse(t1);
	printf("\n**********************\n");
	printf("叶子结点的数目: %d\n", LeafNum(t1));
	printf("************************\n");
	printf("非叶子结点的数目: %d\n", NotLeafNum(t1));
	printf("************************\n");
	printf("深度: %d\n", BiTreeDeepth(t1));
	printf("************************\n");
	Destroy(&t1);
	if (!t1) {
		printf("OK\n");
	}
	system("pause");
	return 0;
}
 
效果图
 
 
希望本篇文章能对大家有所帮助, 真诚希望得到大家的评论和建议

#include "stdio.h"
 #include "malloc.h"
 
typedef struct BiTNode{
     char data;   /*结点的数据域*/
     struct BiTNode *lchild , *rchild;  /*指向左孩子和右孩子*/
 } BiTNode , *BiTree;
 
/*创建一棵二叉树*/
 void CreatBiTree(BiTree *T)
 {
     char c;
     scanf("%c",&c);
     if(c == ' ') *T = NULL;
     else{
        *T = (BiTNode * )malloc(sizeof(BiTNode));  /*创建根结点*/
         (*T)->data = c;    /*向根结点中输入数据*/
         CreatBiTree(&((*T)->lchild));  /*递归地创建左子树*/
         CreatBiTree(&((*T)->rchild));  /*递归地创建右子树*/
     }
 }
 
int getLeavesConut(BiTree T) {
     int leftLeavesCount;
     int rightLeavesCount;
     if (T == NULL) {
         return 0;
     }else if (T->lchild == NULL && T->rchild == NULL) {
         return 1;
     }else {
         leftLeavesCount = getLeavesConut(T->lchild);
         rightLeavesCount = getLeavesConut(T->rchild);
         return leftLeavesCount + rightLeavesCount;
     }
 }
 main()
 {
    BiTree T = NULL;                /*初始化T */
    int count = 0;
    printf("Input some characters to create a binary tree \n");
    CreatBiTree(&T);                /*创建一棵二叉树*/
   count =  getLeavesConut (T);    /*计算二叉树中叶子结点的个数 */
    printf("The number of leaves of BTree are %d\n",count);
    getchar();
    getchar();
 }