樹遞歸演算法

❶ 編寫遞歸演算法，求二叉樹的結點個數和葉子數

00DLR(liuyu *root) /*中序遍歷 遞歸函數*/
{if(root!=NULL)
{if((root->lchild==NULL)&&(root->rchild==NULL)){sum++; printf("%d\n",root->data);}
DLR(root->lchild);
DLR(root->rchild); }
return(0);
}
法二：
int LeafCount_BiTree(Bitree T)//求二叉樹中葉子結點的數目
{
if(!T) return 0; //空樹沒有葉子
else if(!T->lchild&&!T->rchild) return 1; //葉子結點
else return Leaf_Count(T->lchild)+Leaf_Count(T->rchild);//左子樹的葉子數加
上右子樹的葉子數
}//LeafCount_BiTree

註：上機時要先建樹！例如實驗二的方案一。
① 列印葉子結點值（並求總數）
思路：先建樹，再從遍歷過程中列印結點值並統計。

❷ 二叉樹的遞歸演算法到底該怎麼理解

這不就是在二叉排序樹上的遞歸查找，看程序
tree&
find(const
T&
d,
tree&
t){
if(t==NULL)
return
t;如果二叉樹為空則返回空，查找失敗
if(t->data==d)
return
t;否則，如果當前根結點關鍵碼為d，則查找成功，當前根結點為待查找結點
if(d>t->data)
return
find(d,
t->right);如果比根的關鍵碼大就遞歸查找右子樹
return
find(d,
t->left);如果比根的關鍵碼小就遞歸查找左子樹
}
二叉樹的遞歸定義的含義就是非空二叉樹，除了根以外，左右子樹都是二叉樹（可以為空）

❸ 遍歷二叉樹遞歸演算法

「這個函數的參數visit應該是另一個函數的地址是把，但我怎麼感覺不管怎麼遞歸它只是在訪問根的時候被調用過一次」
首先，你是對的，visit確實是一個指向函數的指針；
然後，它只是在訪問根的時候被調用過一次，這種說法就很片面了。
我覺得應該這么說：(*visit)()函數在BTreePreOrger（）函數的一次執行過程中只被調用過一次，但是BTreePreOrger()函數執行了很多次，因此(*visit)()就被調用了n次（假設該樹有n個節點）

❹ 有關二叉樹遞歸的演算法

靠，縮進全被網路搞亂了，自己排版

#include <iostream>
using namespace std;
//二叉樹節點
struct BiTreeNode{
int data;
BiTreeNode *left;
BiTreeNode *right;
};
//寫一個類，方便二叉樹的建立和刪除
class BiTree{
private:
void deleteAllNode(BiTreeNode *root);
public:
BiTreeNode *root;
BiTree();
~BiTree();
void CreateTree();
void deleteLeaves(BiTreeNode *root);
bool DepthOfTheNode(BiTreeNode *currentNode,BiTreeNode *p, int depthOfFather);
void FindMaxValue(BiTreeNode *currentNode, int *maxValue);
void ExchangeLeftAndRight(BiTreeNode *currentNode);
void OutputValueAndDepthByQIANXU(BiTreeNode *currentNode, int depthOfFather); //不好意思，用了拼音
};
BiTree::BiTree()
{
root = NULL;
}
BiTree::~BiTree()
{
deleteAllNode(root);
}
void BiTree::deleteAllNode(BiTreeNode *root)
{
if (root == NULL) return;
deleteAllNode(root->left);
deleteAllNode(root->right);
cout << root->data << ' '; //用來查看當前節點是不是被刪除。
delete root;
}
//手動建立一個二叉樹用於測試
// 1
// / \
// 2 3
// \ /
// 4 5
void BiTree::CreateTree()
{
if (root) return;
root = new BiTreeNode;
root->data = 1;
root->left = new BiTreeNode;
root->left->data = 2;
root->right = new BiTreeNode;
root->right->data = 3;
BiTreeNode *p;
p = root->left;
p->left = NULL;
p->right = new BiTreeNode;
p->right->data = 4;
p->right->left = p->right->right = NULL;
p= root->right;
p->left = new BiTreeNode;
p->left->data = 5;
p->left->left = p->left->right = NULL;
p->right = NULL;
}
//用遞歸演算法刪除葉子
void BiTree::deleteLeaves(BiTreeNode *root)
{
if (root == NULL) return;
if (!root->left && !root->right) return; //表示是根節點(或者出錯，跑到葉子節點了，這種情況應該不會)，不刪除

if (root->left) //當前節點有左子樹
{
if (root->left->left || root->left->right) //左子樹不是葉子
deleteLeaves(root->left);
else //當前節點的左子節點是葉子
{
delete root->left;
root->left = NULL;
}
}
if (root->right)
{
if (root->right->left || root->right->right)
deleteLeaves(root->right);
else //當前節點的右子節點是葉子
{
delete root->right;
root->right = NULL;
}
}
}
int depth = 0; //一個用來存儲深度的全局變數，雖然在實際編程中這樣用不好
//但一切為了方便。
//節點p的深度,遞歸法
bool BiTree::DepthOfTheNode(BiTreeNode *currentNode,BiTreeNode *p, int depthOfFather)
{
if (currentNode == NULL) return false;
if (currentNode == p) //當前節點為要找的節點
{
depth = depthOfFather + 1;
return true;;
}
if (DepthOfTheNode(currentNode->left, p, depthOfFather+1)) //找當前節點的左子樹
return true;
else
return DepthOfTheNode(currentNode->right, p, depthOfFather+1);
}
//用遞歸找最大值，最大值存儲在maxValue所指的內存 ,這里使用前序遍歷
void BiTree::FindMaxValue(BiTreeNode *currentNode, int *maxValue)
{
if (currentNode == NULL) return;
*maxValue = *maxValue > currentNode->data ? *maxValue : currentNode->data;
FindMaxValue(currentNode->left, maxValue); //遍歷左子樹
FindMaxValue(currentNode->right, maxValue);
}
//交換左右，用前序遍歷
void BiTree::ExchangeLeftAndRight(BiTreeNode *currentNode)
{
if (currentNode == NULL) return;
BiTreeNode *temp;
temp = currentNode->left;
currentNode->left = currentNode->right;
currentNode->right = temp;
ExchangeLeftAndRight(currentNode->left);
ExchangeLeftAndRight(currentNode->right);
}
//以前序次序輸出一棵二叉樹所有結點的數據值及結點所在層次
void BiTree::OutputValueAndDepthByQIANXU(BiTreeNode *currentNode, int depthOfFather)
{
if (currentNode == NULL) return;
cout << "節點：" << currentNode->data;
cout << "\t深度：" << depthOfFather+1 << endl;
OutputValueAndDepthByQIANXU(currentNode->left, depthOfFather+1);
OutputValueAndDepthByQIANXU(currentNode->right, depthOfFather+1);
}
int main()
{
BiTree bt;
bt.CreateTree();
//求p的深度
bt.DepthOfTheNode(bt.root, bt.root->left->right, 0);
cout << "深度:" << depth << endl;
//找最大值
int maxValue;
bt.FindMaxValue(bt.root, &maxValue);
cout << "最大值為：" << maxValue << endl;
//交換左右節點
bt.ExchangeLeftAndRight(bt.root);
//以前序次序輸出一棵二叉樹所有結點的數據值及結點所在層次
bt.OutputValueAndDepthByQIANXU(bt.root, 0);
//刪除葉子節點
bt.deleteLeaves(bt.root);
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); 了。分析同上。

這個過程的確比較復雜。慢慢琢磨吧。呵呵。

❻ C語言二叉樹遞歸演算法怎麼做

#include<stdio.h>
#include<string.h>

structtreenode{
intvalue;
treenode*left;
treenode*right;
};
typedeftreenode*BiTree;

voidvisit(treenode*node)
{
printf("%2d",node->value);
}

//結點總數
intnode(BiTreeT)
{
if(!T){
return0;
}
returnnode(T->left)+node(T->right)+1;
}

//前序
voidpreOrder(BiTreeT)
{
if(T){
visit(T);
preOrder(T->left);
preOrder(T->right);
}
}

//中序
voidinOrder(BiTreeT)
{
if(T){
inOrder(T->left);
visit(T);
inOrder(T->right);
}
}

//後序
voidpostOrder(BiTreeT)
{
if(T){
postOrder(T->left);
postOrder(T->right);
visit(T);
}
}

//葉子節點數
intleafnode(BiTreeT)
{
if(T){
if(!T->left&&!T->right)
return1;
else
leafnode(T->left)+leafnode(T->right);
}else{
return0;
}
}

intheight(BiTreeT)
{
if(T){
intlh=height(T->left);
intrh=height(T->right);
return(lh>rh?lh:rh)+1;
}else{
return0;
}
}

intmain()
{


return0;
}

❼ 先序遍歷二叉樹的遞歸演算法怎樣理解（嚴蔚敏主編）

先序調用的時候，遞歸函數，先序函數會一直遞歸，直到t->next為空，即t為葉節點，需要注意的是當t->next 為空時，函數的實參沒有傳過去，所以t指向葉結點的父節點，更要注意的是，先序調用的遞歸函數還沒執行完，在先序調用的最里層，要執行這個函數的最後一個語句，即先序訪問右子樹。
在了解遞歸函數時，要注意函數是一層一層執行的，把沒有調用的函數看作哦是第一層，第一次調用的時候，，勢必會第二次遇到調用函數，變成第二層，，，，

❽ 建立二叉樹的遞歸演算法怎樣理解

不斷地在紙上或腦子里執行每一步，在一點要深刻理解函數的調用和形參和實參的概念，還有return語句。熟能生巧一位牛人說的.

❾ 求統計二叉樹葉子結點數的遞歸演算法

···cpp

由於不知道你的存儲方式，假設你是指針存，用孩子兄弟表示法。

（偽）代碼：

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

就這樣

❿ 關於遞歸演算法求二叉樹深度演算法

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;

這個就是終止條件了，如果沒有子節點就返回。