⑴ 关于递归算法求二叉树深度算法
u,v 分别求出当前节点左子树和右子树的深度（高度），
然后当前节点的 深度就等于左右子树里面较大的那个+1.
if (u>n) return (u+1)
return (v+1)
这句就是返回较深的+1.
u=height(T->lchild);
v=height(T->rchild);
这两句就是递归的调用，求深度了。
if (T==NULL) return 0;
这个就是终止条件了，如果没有子节点就返回。
⑵ 关于求二叉树深度的递归算法
关于递归，你可以看成是一句一句往下运行嘛。需要保存状态的时候，系统就会自动用栈帮你保存。就依你说得那个为例：
n为全局变量，初值为0；
第一次调用height(T)，假设T！=NULL
由于T!=NULL：跳过if (T==NULL) return 0;
关键到了u=height(T->lchild); 调用本身的函数：此时的T->lchild保存在栈中，既然是调用就得从函数开头执行：
看下这时候T2（其实就是T->lchild），if (T==NULL) return 0；
这里假设T不是NULL，就继续运行在遇到u=height(T->lchild); 在调这个函数本身——
这里就假设它为T->lchild==NULL吧。这下可好，这个函数执行return 0；
慢着：第二次函数调用u=height(T->lchild)中的函数值已经计算出来啦。这时u=0；
你还记得第二次调用运行到了v=height(T->rchild); 这句话吧？好，这个过程就和u=height(T->lchild)完全一样。
这里也假设得到的v=0
则第二次调用到了if (u>n) return (u+1)
return (v+1)
得到一个返回值，不如就假设u〉n，于是返回值1；
好，这一波完毕；
你还记得第一次调用的height吧，这时把返回值给u,u=1；
然后执行到第一次调用中的v=height(T->rchild); 了。分析同上。
这个过程的确比较复杂。慢慢琢磨吧。呵呵。
⑶ Java数据结构二叉树深度递归调用算法求内部算法过程详解
二叉树
1
2
3
4
5
6
7
这个二叉树的深度是3，树的深度是最大结点所在的层，这里是3.
应该计算所有结点层数，选择最大的那个。
根据上面的二叉树代码，递归过程是：
f
(1)=f
(2)+1
>
f
(3)
+1
?
f(2)
+
1
:
f(3)
+1
f(2)
跟f(3)计算类似上面，要计算左右结点，然后取大者
所以计算顺序是f(4.left)
=
0,
f(4.right)
=
0
f
(4)
=
f(4.right)
+
1
=
1
然后计算f(5.left)
=
0,f(5.right)
=
0
f
(5)
=
f(5.right)
+
1
=1
f(2)
=
f(5)
+
1
=2
f(1.left)
计算完毕，计算f(1.right)
f(3)
跟计算f(2)的过程一样。
得到f(3)
=
f(7)
+1
=
2
f(1)
=
f(3)
+
1
=3
12345if(depleft>depright){ return depleft+1;}else{ return depright+1;}
只有left大于right的时候采取left
+1，相等是取right
⑷ 试编写一个计算二叉树深度的递归算法
int Depth(BiTree T)/* 深度 */
{if(T==NULL)
return(0);
else
return 1+(Depth(T->lchild)>Depth(T->rchild)? Depth(T->lchild):Depth(T->rchild));
}
⑸ 如何求二叉树深度的递归算法是什么
int height(Bitree T) { if (T==NULL) return 0; u=height(T->lchild); v=height(T->rchild); if (u>n) return (u+1) //n应该是v return (v+1) } if 中的n应该是v。 其思想是，一个节点的深度是他的两个子节点中深度的最大值再加上1。
⑹ 求解具有n个结点的完全二叉树的深度，写出计算过程
具有n个结点的完全二叉树的深度为“log2n”+1
计算过程如下：
采用数学归纳法证明。
当n=1=2^1-1时，命题成立。
假设当n<=2^k-1时具有n个结点的完全二叉树的深度为“log2n”+1,
则当n=2^k（以及2^k+1,...,2^(k+1)-1）时，由归纳假设知：
前2^k-1个结点构成深度为“log2n”+1的树；
再由完全二叉树的定义知：
剩余的1（或2,...,2^k)个结点均填在第“log2n”+2层上（作为“叶子”），深度刚好增加了1，
故n<=2^(k+1)-1时，命题成立。
(6)求树的深度递归算法扩展阅读：
二叉树是一种树型结构，它的特点是每个结点至多只有二棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。
二叉树的性质
1、在二叉树的第i层上至多有2i-1个结点；
2、深度为k的二叉树至多有2k-1个结点（k>=1）；
3、对任何一棵二叉树T，如果其终端结点数为N0，度为2的结点数为N2，则N0=N2+1；
4、具有n个结点的完全二叉树的深度为“log2n”+1。
⑺ 写出二叉树深度的算法
基本思路就是如果当前节点还有子节点，则继续访问，递归的找寻子节点直到叶子节点为止。
procere
tree(a:node,depth:integer);
begin
if
result<depth
then
result:=depth;
if
a.leftchild<>nil
then
tree(a.leftchild,depth+1);
if
a.rightchild<>nil
then
tree(a.rightchild,depth+1);
end;
注:result是全局变量,是结果
实际上最好不用什么全局变量
int
depth(node
*bt)
{
if
(bt==NULL)
return
0;
ldepth=depth(bt->left)+1;
rdepth=depth(bt->right)+1;
return
max(ldepth,rdepth);
}
全局变量是bug
int
Height(BiTree
T){
int
m,n;
if(!T)
return(0);
else
m=Height(T->lchild);
n=Height(T->rchild);
return((m>n?m:n)+1);
}
求树深度的递归算法
//
struct
bnode{struct
bnode
*lc,*rc);
int
depth(struct
bnode
*r)
{
return
r==NULL?0:1+max(depth(r->lc),depth(r->rc));
}
⑻ 用递归的方法设计一个建立二叉树并求其深度的算法,求完整的。
先序遍历求二叉树高度int PreTreeDepth(BiTree root)
#define null 0
typedef struct node
{
elementtype data;
struct node *RChild,*LChild;
}BitNode,*BiTree;
int PreTreeDepth(BiTree root)
{/*先序遍历求二叉树高度，root为指向二叉树根结点的指针*/
int lc,rc,max=0;
if(root==null)
return max;
lc=PreTreeDepth(root->LChild);
rc=PreTreeDepth(root->RChild);
max=lc>rc?lc:rc;
return max+1;
}
后序遍历求二叉树高度int PostTreeDepth(BiTree root)
#define null 0
typedef struct node
{
elementtype data;
struct node *RChild,*LChild;
}BitNode,*BiTree;
int PostTreeDepth(BiTree root)
{/*后序遍历二叉树，root为指向二叉树（或某一子树）根结点的指针*/
int max=0;
if(root!=null)
{
max=PostTreeDepth(root->LChild)+1;
if(max<=PostTreeDepth(root->RChild))
max=PostTreeDepth(root->RChild)+1;
}
return max;
}
⑼ 用递归算法求二叉树的深度
return语句仅结束当前的函数调用。如果是循环调用，仅结束当前层次的调用，并返回上一层次。
对于
int depth(BTree root){
...
if(!root)
return 0;
else{
...
if(ldepth ＞= rdepth)
return ldepth+1;
else
return rdepth+1;
}
return 1;
}
最后一个“return 1;”不会被执行到的。
⑽ 在求二叉树的深度递归算法中程序是如何实现深度的计算的
空节点（指针值为NULL）的深度为0；
叶子节点（左、右子树均为空节点）的深度为1；
其它节点，其深度为其左、右子树中深度较大者加1。