编程叶子节点

⑴ 求统计二叉树叶子结点数的递归算法

···cpp

由于不知道你的存储方式，假设你是指针存，用孩子兄弟表示法。

（伪）代码：

structnode{
data{
...
}val;
node*fchild,*brother;
}
voidgetnum(nodex){
if(x.fchild==nu)ans++;
else{
getnum(*x.fchild);
getnum(*x.brother);
}
}

就这样

⑵ c语言二叉树的统计叶子节点问题

intPreOrder(BiTreeroot){
inti=0;
if(root==NULL)return0;
if(root->lchild==NULL&&root->rchild==NULL){
i++;
}
printf("%c",root->data);
intj=PreOrder(root->lchild);
intk=PreOrder(root->rchild);
returni+j+k;
}

⑶ 怎么计算C语言的二叉树中的叶子节点数

结点的度是指，该结点的子树的个数，在二叉树中，不存在度大于2的结点。
计算公式：n0=n2+1
n0
是叶子节点的个数
n2
是度为2的结点的个数
n0=n2+1=5+1=6
故二叉树有5个度为2的结点，则该二叉树中的叶子结点数为6。
(3)编程叶子节点扩展阅读
叶子结点是离散数学中的概念。一棵树当中没有子结点（即度为0）的结点称为叶子结点，简称“叶子”。
叶子是指度为0的结点，又称为终端结点。
叶子结点
就是度为0的结点
就是没有子结点的结点。
n0：度为0的结点数，n1:度为1的结点
n2：度为2的结点数。
N是总结点
在二叉树中：
n0=n2+1；
N=n0+n1+n2
参考资料：叶子结点_网络

⑷ 在VB编程中，详细解释一下什么是二叉树，叶子结点，度的含义和关系。

同意楼上，二叉树，一种数据类型，看看你的资源管理器就明白了，资源管理器的文件夹相当于二叉树的叶子，可以展开的加号相当于节点，度就是从根目录到目标文件夹经过的加号的个数相当于度
c:
|
+——windows
|
+——+user
...|
...+desktop
那么desktop的度就是4，并且是叶子，windows，user为节点。
二叉树，顾名思义，只能分两个叉，一个叉表示和自身同级的文件夹，另一个表示包含的文件夹
一般左分叉为自身同级的文件夹，右为包含的文件夹

⑸ 在VB编程中，详细解释一下什么是二叉树，叶子结点，度的含义和关系。

二叉树是一类非常重要的树形结构,它可以递归地定义如下:
二叉树T是有限个结点的,它或者是空集,或者由一个根结点u以及分别称为左子树和右子树的两棵互不相交的二叉树u(1)和u(2)组成。
结点的孩子结点个数即为该结点的度.
度为0的结点叫叶子结点.
处在树的最顶端(没有双亲)的结点叫根结点.

⑹ c语言中叶子节点数和节点数有什么不同

叶子节点指一棵树上所有终端节点，按照从上向下画的方式，就是最“下面”的节点。

而节点包含所有节点，也就是除了叶子节点外，还有根节点和中间节点。

以下图为例：

叶子节点只包括C,D,E三个节点，所以这个树的叶子节点数为3。

而计算节点数要包括所有节点，即A,B,C,D,E，所以节点数为5。

⑺ 用C语言编程，以二叉链表为存储结构，并以先跟序列输入创建二叉树，求叶子结点树

#include<stdio.h>
#include<stdlib.h>
typedef struct bitnode
{
char data;
struct bitnode *lchild,*rchild;
}bitnode,*bitree;
bitree create_tree() //先序创建
{
char a;bitree root;
scanf("%c",&a);
fflush(stdin);
if(a=='#')return NULL;
else
{
root=(bitnode *)malloc(sizeof(bitnode));
root->data=a;
root->lchild=create_tree();
root->rchild=create_tree();
}
return root;
}

void inorder(bitree root)//中根遍历
{
bitree s[100];
int top=0;
while(root||top)
{
while(root)
{
s[++top]=root;root=root->lchild;
}
if(top)
{
putchar(s[top]->data);
root=s[top--]->rchild;
}
}
}
int leafcount(bitree root)//计算叶子节点个数
{
if(!root)return 0;
else
{
if(!(root->lchild)&&!(root->rchild))return 1;
else return leafcount(root->lchild)+leafcount(root->rchild);
}
}
void main()
{
bitree root=NULL;
root=create_tree();//输入序列为先序遍历序列，＃代表空
printf("中序遍历结果为：\n");
inorder(root);printf("\n");
printf("叶子节点个数为%d\n",leafcount(root));
printf("\n");
}

//输入先序序列例如ab＃＃c＃＃（每输入一次回车）不能省略＃（代表空）

⑻ 数据结构编程： 统计二叉树中叶子结点的个数。

叶子节点：没有孩子节点的节点

也就是说，当我们明白了叶子节点的定义后，只需要遍历一遍二叉树，把符合这种条件（左孩子节点和右孩子节点都为NULL的节点）的节点统计出来就可以了。

于是，实际上这个问题也就转化成了如何遍历二叉树？很显然，遍历二叉树是可以有多种方式的，如：前序遍历（递归/非递归）、中序遍历（递归/非递归）、后序遍历（递归/非递归）、层次遍历等等。

下面我将给出使用递归前序遍历以及层次遍历两种思路实现的求解叶子节点的示例代码吧，仅供参考。其他几种实现方式思路类似，可自行尝试。示例代码如下：

java">packagecn.zifangsky.tree.questions;

importorg.junit.Test;

importcn.zifangsky.queue.LinkQueue;
importcn.zifangsky.tree.BinaryTreeNode;

/**
*求二叉树中叶子节点的个数
*@authorAdministrator
*
*/
publicclassQuestion2{

	/**
	*通过递归前序遍历获取叶子节点个数
	*@paramroot
	*@return
	*/
	(BinaryTreeNoderoot){
		if(root==null){
			return0;
		}else{
			if(root.getLeft()==null&&root.getRight()==null){//叶子节点
				return1;
			}else{
				(root.getLeft())+getNumberOfLeavesByPreOrder(root.getRight());
			}
		}

	}
	
	
	/**
	*使用层次遍历获取二叉树叶子节点个数
	*
	*@时间复杂度O(n)
	*@paramroot
	*/
	(BinaryTreeNoderoot){
		intcount=0;//叶子节点总数
		LinkQueue<BinaryTreeNode>queue=newLinkQueue<>();
		if(root!=null){
			queue.enQueue(root);
		}
		
		while(!queue.isEmpty()){
			BinaryTreeNodetemp=(BinaryTreeNode)queue.deQueue();
			//叶子节点：左孩子节点和右孩子节点都为NULL的节点
			if(temp.getLeft()==null&&temp.getRight()==null){
				count++;
			}else{
				if(temp.getLeft()!=null){
					queue.enQueue(temp.getLeft());
				}
				if(temp.getRight()!=null){
					queue.enQueue(temp.getRight());
				}
			}
		}
		returncount;
	}
	
	
	/**
	*测试用例
	*/
	@Test
	publicvoidtestMethods(){
		/**
		*使用队列构造一个供测试使用的二叉树
		*1
		*23
		*4567
		*89
		*/
		LinkQueue<BinaryTreeNode>queue=newLinkQueue<BinaryTreeNode>();
		BinaryTreeNoderoot=newBinaryTreeNode(1);//根节点
		
		queue.enQueue(root);
		BinaryTreeNodetemp=null;
		for(inti=2;i<10;i=i+2){
			BinaryTreeNodetmpNode1=newBinaryTreeNode(i);
			BinaryTreeNodetmpNode2=newBinaryTreeNode(i+1);
			
			temp=(BinaryTreeNode)queue.deQueue();
			
			temp.setLeft(tmpNode1);
			temp.setRight(tmpNode2);
			
			if(i!=4)
				queue.enQueue(tmpNode1);
			queue.enQueue(tmpNode2);
		}

		System.out.println("叶子节点个数是："+getNumberOfLeavesByPreOrder(root));
		System.out.println("叶子节点个数是："+getNumberOfLeavesByQueue(root));
		
	}

}

测试代码输出如下：

叶子节点个数是：5
叶子节点个数是：5

附：

二叉树节点BinaryTreeNode的定义：

packagecn.zifangsky.tree;

publicclassBinaryTreeNode{
	privateintdata;//数据
	privateBinaryTreeNodeleft;//左孩子节点
	privateBinaryTreeNoderight;//右孩子节点
	
	publicBinaryTreeNode(intdata){
		this.data=data;
	}

	publicBinaryTreeNode(intdata,BinaryTreeNodeleft,BinaryTreeNoderight){
		this.data=data;
		this.left=left;
		this.right=right;
	}

	publicintgetData(){
		returndata;
	}

	publicvoidsetData(intdata){
		this.data=data;
	}

	publicBinaryTreeNodegetLeft(){
		returnleft;
	}

	publicvoidsetLeft(BinaryTreeNodeleft){
		this.left=left;
	}

	publicBinaryTreeNodegetRight(){
		returnright;
	}

	publicvoidsetRight(BinaryTreeNoderight){
		this.right=right;
	}
	
}

队列LinkQueue的定义：

packagecn.zifangsky.queue;

importcn.zifangsky.linkedlist.SinglyNode;

/**
*基于单链表实现的队列
*@authorzifangsky
*@param<K>
*/
publicclassLinkQueue<KextendsObject>{
	privateSinglyNode<?>frontNode;//队首节点
	privateSinglyNode<?>rearNode;//队尾节点
	
	publicLinkQueue(){
		frontNode=null;
		rearNode=null;
	}
	
	/**
	*返回队列是否为空
	*@时间复杂度O(1)
	*@return
	*/
	publicbooleanisEmpty(){
		return(frontNode==null);
	}
	
	/**
	*返回存储在队列的元素个数
	*@时间复杂度O(n)
	*@return
	*/
	publicintsize(){
		intlength=0;
		SinglyNode<?>currentNode=frontNode;
		while(currentNode!=null){
			length++;
			currentNode=currentNode.getNext();
		}
		
		returnlength;
	}
	
	/**
	*入队：在链表表尾插入数据
	*@时间复杂度O(1)
	*@paramdata
	*/
	publicvoidenQueue(Kdata){
		SinglyNode<K>newNode=newSinglyNode<K>(data);
		
		if(rearNode!=null){
			rearNode.setNext(newNode);
		}
			
		rearNode=newNode;
		
		if(frontNode==null){
			frontNode=rearNode;
		}
	}
	
	/**
	*出队：删除表头节点
	*@时间复杂度O(1)
	*@return
	*/
	publicObjectdeQueue(){
		if(isEmpty()){
			thrownewRuntimeException("QueueEmpty!");
		}else{
			Objectresult=frontNode.getData();
			
			if(frontNode==rearNode){
				frontNode=null;
				rearNode=null;
			}else{
				frontNode=frontNode.getNext();
			}
			
			returnresult;
		}
	}
	
}

单链表节点SinglyNode的定义：

packagecn.zifangsky.linkedlist;

/**
*单链表的定义
*@authorzifangsky
*@param<K>
*/
publicclassSinglyNode<KextendsObject>{
	privateKdata;//数据
	privateSinglyNode<?>next;//该节点的下个节点

	publicSinglyNode(Kdata){
		this.data=data;
	}

	publicSinglyNode(Kdata,SinglyNode<?>next){
		this.data=data;
		this.next=next;
	}

	publicKgetData(){
		returndata;
	}

	publicvoidsetData(Kdata){
		this.data=data;
	}

	publicSinglyNode<?>getNext(){
		returnnext;
	}

	publicvoidsetNext(SinglyNode<?>next){
		this.next=next;
	}

	@Override
	publicStringtoString(){
		return"SinglyNode[data="+data+"]";
	}

}

⑼ C语言求树中的叶子结点数

有从上至下和从下至上两种方式可以统计树的节点数。
设叶子节点（度为0的节点）数为x：
从上至下时，度为n的节点有n个子节点，再加上根节点，总结点数量为1+4×1+3×2+2×3+1×4+0×n=21
从下至上时，节点数为度为0~4的所有节点数相加，总节点数量为1+2+3+4+n=10+n
所以有21=10+n，得n=11.