樹度的演算法
Ⅰ C語言關於二叉樹的度的演算法
可憐的管理員哭泣著亂踹兩腳
被映得粉亮的翅膀，直到拖著尖銳的
我們為之乾杯的死亡，
父親戴一件絨毛狀火紅頭飾
讓路。白日懷疑自己，
她每天只就讓復一個工作哈哈
Ⅱ 二叉樹的深度怎麼算
二叉樹的深度計算，首先要判斷節點，以下是計算二叉樹的詳細步驟：
1、一顆樹只有一個節點，它的深度是1；
2、二叉樹的根節點只有左子樹而沒有右子樹，那麼可以判斷，二叉樹的深度應該是其左子樹的深度加1；
3、二叉樹的根節點只有右子樹而沒有左子樹，那麼可以判斷，那麼二叉樹的深度應該是其右樹的深度加1；
4、二叉樹的根節點既有右子樹又有左子樹，那麼可以判斷，那麼二叉樹的深度應該是其左右子樹的深度較大值加1。
一棵深度為k，且有2^k-1個節點的二叉樹，稱為滿二叉樹。這種樹的特點是每一層上的節點數都是最大節點數。而在一棵二叉樹中，除最後一層外，若其餘層都是滿的，並且最後一層或者是滿的，或者是在右邊缺少連續若干節點，則此二叉樹為完全二叉樹。
具有n個節點的完全二叉樹的深度為floor(log2n)+1。深度為k的完全二叉樹，至少有2k-1個葉子節點，至多有2k-1個節點。
5、有N個結點的完全二叉樹各結點如果用順序方式存儲，則結點之間有如下關系：
若I為結點編號則 如果I>1，則其父結點的編號為I/2；
如果2*I<=N，則其左孩子（即左子樹的根結點）的編號為2*I；若2*I>N，則無左孩子；
Ⅲ 二叉樹深度的演算法
#include"stdio.h"
#include"alloc.h"
typedef
char
datatype;
typedef
struct
node
{
datatype
data;
struct
node
*lchild,
*rchild;
}
bitree;
int
k
=
1;
bitree
*Q[10];
bitree
*CREAT()
{
char
ch;
int
front,
rear;
bitree
*root,
*s;
root
=
NULL;
front
=
1;
rear
=
0;
printf("\n
=======
二叉樹
的建立和遍歷=======\n");
printf("
請輸入字元:
");
ch
=
getchar();
while
(ch
!=
'$')
{
s
=
NULL;
if
(ch
!=
'@')
{
s
=
malloc(sizeof(bitree));
s
->
data
=
ch;
s
->
lchild
=
NULL;
s
->
rchild
=
NULL;
}
rear++;
k
=
k++;
Q[rear]
=
s;
if
(rear
==
1)
root
=
s;
else
{
if
(s
&&
Q[front])
if
(rear
%
2
==
0)
Q[front]
->
lchild
=
s;
else
Q[front]
->
rchild
=
s;
if
(rear
%
2
==
1)
front++;
}
ch
=
getchar();
}
return
root;
}
int
COUNTER(t)
bitree
*t;
{
if
(t
==
NULL)
return
0;
else
if
(t->lchild
!=
NULL
&&
t->rchild
==
NULL
||
t->lchild
==
NULL
&&
t->rchild
!=
NULL)
return
1;
else
return
COUNTER(t->lchild)
+
COUNTER(t->rchild);
}
main()
{
int
i;
bitree
*p;
p
=
CREAT();
printf("
建立的二叉樹為:
");
for
(i
=
0;
i
<
k;
i++)
{
printf("%c
",
Q[i]
->
data);
}
printf("\n
度為1的節點數為：
");
printf("%d
",
COUNTER(p));
}
這是二叉樹的建立
遍歷
加二叉樹的度為1的結點的演算法
Ⅳ 關於求二叉樹深度的遞歸演算法
關於遞歸，你可以看成是一句一句往下運行嘛。需要保存狀態的時候，系統就會自動用棧幫你保存。就依你說得那個為例：
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); 了。分析同上。
這個過程的確比較復雜。慢慢琢磨吧。呵呵。
Ⅳ 二叉樹的深度演算法怎麼算啊
二叉樹的深度演算法：
一、遞歸實現基本思想：
為了求得樹的深度，可以先求左右子樹的深度，取二者較大者加1即是樹的深度，遞歸返回的條件是若節點為空，返回0
演算法：
1
int
FindTreeDeep(BinTree
BT){
2
int
deep=0;
3
if(BT){
4
int
lchilddeep=FindTreeDeep(BT->lchild);
5
int
rchilddeep=FindTreeDeep(BT->rchild);
6
deep=lchilddeep>=rchilddeep?lchilddeep+1:rchilddeep+1;
7
}
8
return
deep;
9
}
二、非遞歸實現基本思想：
受後續遍歷二叉樹思想的啟發，想到可以利用後續遍歷的方法來求二叉樹的深度，在每一次輸出的地方替換成算棧S的大小，遍歷結束後最大的棧S長度即是棧的深度。
演算法的執行步驟如下：
（1）當樹非空時，將指針p指向根節點，p為當前節點指針。
（2）將p壓入棧S中，0壓入棧tag中，並令p執行其左孩子。
（3）重復步驟（2），直到p為空。
（4）如果tag棧中的棧頂元素為1，跳至步驟（6）。從右子樹返回
（5）如果tag棧中的棧頂元素為0，跳至步驟（7）。從左子樹返回
（6）比較treedeep與棧的深度，取較大的賦給treedeep，對棧S和棧tag出棧操作，p指向NULL，並跳至步驟（8）。
（7）將p指向棧S棧頂元素的右孩子，彈出棧tag，並把1壓入棧tag。（另外一種方法，直接修改棧tag棧頂的值為1也可以）
（8）循環（2）~（7），直到棧為空並且p為空
（9）返回treedeep，結束遍歷
1
int
TreeDeep(BinTree
BT
){
2
int
treedeep=0;
3
stack
S;
4
stack
tag;
5
BinTree
p=BT;
6
while(p!=NULL||!isEmpty(S)){
7
while(p!=NULL){
8
push(S,p);
9
push(tag,0);
10
p=p->lchild;
11
}
12
if(Top(tag)==1){
13
deeptree=deeptree>S.length?deeptree:S.length;
14
pop(S);
15
pop(tag);
16
p=NULL;
17
}else{
18
p=Top(S);
19
p=p->rchild;
20
pop(tag);
21
push(tag,1);
22
}
23
}
24
return
deeptree;
25
}
Ⅵ 求二叉樹高度的原理、演算法是什麼，越詳細越好，C語言，謝謝
首先分析二叉樹的深度（高度）和它的左、右子樹深度之間的關系。從二叉樹深度的定義可知，二叉樹的深度應為其左、右子樹深度的最大值加1。由此，需先分別求得左、右子樹的深度，演算法中「訪問結點」的操作為：求得左、右子樹深度的最大值，然後加
1
。
int
Depth
(BiTree
T
){
//
返回二叉樹的深度
if
(
!T
)
depthval
=
0;
else
{
depthLeft
=
Depth(
T->lchild
);
depthRight=
Depth(
T->rchild
);
depthval
=
1
+
(depthLeft
>
depthRight
?
depthLeft
:
depthRight);
}
return
depthval;
}
Ⅶ 關於遞歸演算法求二叉樹深度演算法
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;
這個就是終止條件了，如果沒有子節點就返回。
Ⅷ 求一個關於求二叉樹度為2的結點數 的演算法
分析:二叉樹中2度結點數的遞歸定義為
①當T為空或為葉子時,以T為根的二叉樹的2度結點數為0;
②當T是2度結點時,以T為根的二叉樹的2度結點數為T的左右子樹中2度結點數這和再加上T結點本身;
③當T是1度結點時,以T為根的二叉樹中2度結點數為T的左或子樹中2度結點數之和.
其演算法如下:
int D2Nodes(BinTree T){
if(!T||!T->lchild&&!T->rchild) //T為空或是葉子
return 0;
if(T->lchild&&T->rchild) //T是2度結點
return 1+D2Nodes(T->lchild)+D2Nodes(T->rchild);
else //T是1度結點
return D2Nodes(T->lchild)+D2Nodes(T->rchild);
}
Ⅸ 對以孩子鏈表表示的樹編寫計算樹的深度的演算法
typedef struct TreeNode
{
TreeNode *child;
TreeNode *sibling;
int data;
}TreeNode;
//這是用了遞歸的思想，需要仔細體會
int GetChildeSiblingTreeDegree(TreeNode *root)
{
//如果當前樹的根節點沒有孩子和兄弟，那麼，該樹的度就是0
if (root->child == NULL && root->sibling == NULL)
{
return 0;
}
//如果該樹只有兄弟，則該樹的度就等效於對他的兄弟分支的子樹求度
else if( root->sibling != NULL)
{
return GetChildeSiblingTreeDegree(root->sibling);
}
//如果該樹只有孩子，那麼先求出該根節點的度，然後再對它孩子分支子樹求度，兩者取較大者，即該樹的度
else if(root->child != NULL)
{
int rootDegree = 1;
TreeNode *p = root->child;
while(p->sibling != NULL)
{
p = p->sibling;
rootDegree++;
}
int childTreeDegree = GetChildeSiblingTreeDegree(root->child);
return rootDegree > childTreeDegree ? rootDegree : childTreeDegree;
}
}
Ⅹ 葉子節點數計算公式是什麼
結點的度是指，該結點的子樹的個數，在二叉樹中，不存在度大於2的結點。
計算公式：n0=n2+1
n0 是葉子節點的個數
n2 是度為2的結點的個數
n0=n2+1=5+1=6
故二叉樹有5個度為2的結點，則該二叉樹中的葉子結點數為6。
(10)樹度的演算法擴展閱讀：
葉子結點就是度為0的結點，就是沒有子結點的結點。
n0：度為0的結點數，n1:度為1的結點 n2：度為2的結點數，N是總結點。
在二叉樹中：
n0=n2+1；
N=n0+n1+n2