树递归算法_C语言二叉树递归算法怎么做

Ⅰ 建立二叉树的递归算法怎样理解

不断地在纸上或脑子里执行每一步，在一点要深刻理解函数的调用和形参和实参的概念，还有return语句。熟能生巧一位牛人说的.

Ⅱ 编写递归算法，求二叉树的结点个数和叶子数

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

注：上机时要先建树！例如实验二的方案一。
① 打印叶子结点值（并求总数）
思路：先建树，再从遍历过程中打印结点值并统计。

Ⅲ 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;
}

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

···cpp

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

（伪）代码：

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

就这样

Ⅳ 关于求二叉树深度的递归算法

关于递归，你可以看成是一句一句往下运行嘛。需要保存状态的时候，系统就会自动用栈帮你保存。就依你说得那个为例：
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); 了。分析同上。

这个过程的确比较复杂。慢慢琢磨吧。呵呵。

Ⅵ 二叉树的递归算法到底该怎么理解

这不就是在二叉排序树上的递归查找，看程序
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);如果比根的关键码小就递归查找左子树
}
二叉树的递归定义的含义就是非空二叉树，除了根以外，左右子树都是二叉树（可以为空）

Ⅶ 有关二叉树递归的算法

靠，缩进全被网络搞乱了，自己排版

#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;
}

Ⅷ 1．编写递归算法，计算二叉树中叶子结点的数目

int BtreeDepth(BiTNode *BT){//求二叉树的深度
if (BT==NULL)//空树则返回0
return 0;
else{
int dep1=BtreeDepth(BT->lchild );//递归调用逐层分析
int dep2=BtreeDepth(BT->rchild );
if(dep1>dep2)
return dep1+1;
else
return dep2+1;
}
}
int Leave(BiTNode *BT){//求二叉树中的叶子节点数
if (BT==NULL)
return 0;
else{
if(BT->lchild ==NULL && BT->rchild ==NULL)
return 1;
else
return(Leave(BT->lchild )+Leave(BT->rchild ));
}
}

这是学数据结构时做的练习，用的是递归的形式，理解时需稍稍的想一下，但是函数这样写起来会相对比较的简单。

Ⅸ 先序遍历二叉树的递归算法怎样理解（严蔚敏主编）

先序调用的时候，递归函数，先序函数会一直递归，直到t->next为空，即t为叶节点，需要注意的是当t->next 为空时，函数的实参没有传过去，所以t指向叶结点的父节点，更要注意的是，先序调用的递归函数还没执行完，在先序调用的最里层，要执行这个函数的最后一个语句，即先序访问右子树。
在了解递归函数时，要注意函数是一层一层执行的，把没有调用的函数看作哦是第一层，第一次调用的时候，，势必会第二次遇到调用函数，变成第二层，，，，

Ⅹ 遍历二叉树递归算法

“这个函数的参数visit应该是另一个函数的地址是把，但我怎么感觉不管怎么递归它只是在访问根的时候被调用过一次”
首先，你是对的，visit确实是一个指向函数的指针；
然后，它只是在访问根的时候被调用过一次，这种说法就很片面了。
我觉得应该这么说：(*visit)()函数在BTreePreOrger（）函数的一次执行过程中只被调用过一次，但是BTreePreOrger()函数执行了很多次，因此(*visit)()就被调用了n次（假设该树有n个节点）

导航:首页 > 源码编译 > 树递归算法

树递归算法

与树递归算法相关的资料