求树的遍历、树的叶子节点个数、树的高度、copy树

#include<iostream>

using namespace std;

typedef struct Treenode
{
    Treenode* leftchild;//不能定义成struct Treenode leftchild，因为这样就等于循环定义了，系统不知道该分配多少内存给该结构体
    Treenode* rightchild;
    int data;
}TreeNode,*pTreeNode;

//前序遍历
void Pre_reverse(pTreeNode root)
{
    if(root == NULL)
    {
        return;
    }

    //先遍历根节点
    cout<<root->data<<" ";

    //再遍历左子树
    Pre_reverse(root->leftchild);

    //最后遍历右子树
    Pre_reverse(root->rightchild);
}

//中序遍历
void Mid_reverse(pTreeNode root)
{
    if(root == NULL)
    {
        return;
    }

    //先遍历左节点
    Mid_reverse(root->leftchild);

    //再遍历根节点
    cout<<root->data<<" ";

    //最后遍历右子树
    Mid_reverse(root->rightchild);
}

//后序遍历
void Aft_reverse(pTreeNode root)
{
    if(root == NULL)
    {
        return;
    }

    //先遍历左节点
    Aft_reverse(root->leftchild);

    //再遍历右子树
    Aft_reverse(root->rightchild);

    //最后遍历根节点
    cout<<root->data<<" ";
}

//求二叉树中叶子节点的个数，存储在leafnum中
void Leaf_size(pTreeNode root,int &leafnum)
{
    if(!root)
    {
        return;
    }

    if(!root->leftchild && !root->rightchild)
    {
        leafnum++;
    }

    Leaf_size(root->leftchild,leafnum);
    Leaf_size(root->rightchild,leafnum);
}


//求二叉树的高度，存储在treehig中
void Treehig_size(pTreeNode root,int &treehig)
{
    int midtreehig1=0,midtreehig2=0;//每次递归时的中间变量，用来存储根到左子树叶子的高度和根到右子树叶子的高度

    if(!root)
    {
        return;
    }

    treehig++;//递归向下遍历一颗树时，当某个节点不为空时，将树的高度加1
    midtreehig2=treehig;
    if(root->leftchild)
    {
        Treehig_size(root->leftchild,treehig);
    }
    midtreehig1=treehig;//midtreehig1存储根到左子树叶子的高度
    treehig=midtreehig2;//回到这次递归左子树前树的高度

    if(root->rightchild)
    {
        Treehig_size(root->rightchild,treehig);
    }
    midtreehig2=treehig;//midtreehig2存储根到右子树叶子的高度

    treehig=midtreehig1>=midtreehig2?midtreehig1:midtreehig2;//得到这次递归树的高度
}

 

//copy一颗二叉树，思想和遍历二叉树一样
pTreeNode Copy_tree(pTreeNode root)
{
    if(root == NULL)
    {
        return NULL;
    }

    //先遍历根节点
    pTreeNode subroot=(pTreeNode)malloc(sizeof(TreeNode));

    memset(subroot,0,sizeof(TreeNode));

    subroot->data=root->data;
    subroot->leftchild=root->leftchild;
    subroot->rightchild=root->rightchild;

    //再遍历左子树
    Copy_tree(root->leftchild);

    //最后遍历右子树
    Copy_tree(root->rightchild);

    return subroot;
}

int main()
{
    //建立一颗树
    TreeNode t1,t2,t3,t4,t5,t6,t7;
    memset(&t1,0,sizeof(TreeNode));
    memset(&t2,0,sizeof(TreeNode));
    memset(&t3,0,sizeof(TreeNode));
    memset(&t4,0,sizeof(TreeNode));
    memset(&t5,0,sizeof(TreeNode));
    memset(&t6,0,sizeof(TreeNode));
    memset(&t7,0,sizeof(TreeNode));

    t1.data=1;
    t2.data=2;
    t3.data=3;
    t4.data=4;
    t5.data=5;
    t6.data=6;
    t7.data=7;

    t1.leftchild=&t2;
    t1.rightchild=&t3;
    t2.rightchild=&t4;
    t3.leftchild=&t5;
    t4.leftchild=&t6;
    t6.leftchild=&t7;

    cout<<"前序遍历：";
    Pre_reverse(&t1);
    cout<<endl;

    cout<<"中序遍历：";
    Mid_reverse(&t1);
    cout<<endl;

    cout<<"后续遍历：";
    Aft_reverse(&t1);
    cout<<endl;

    //求树的叶子节点的个数
    int leaf_num=0;
    Leaf_size(&t1,leaf_num);
    cout<<"树的叶子节点个数是："<<leaf_num<<endl;

    //求树的高度
    int tree_hig=0;
    Treehig_size(&t1,tree_hig);
    cout<<"树的高度是："<<tree_hig<<endl;

    //copy树
    pTreeNode copy_tree=Copy_tree(&t1);
    cout<<"copy树的前序遍历：";
    Pre_reverse(copy_tree);
    cout<<endl;

    cout<<"copy树的中序遍历：";
    Mid_reverse(copy_tree);
    cout<<endl;

    cout<<"copy树的后序遍历：";
    Aft_reverse(copy_tree);
    cout<<endl;

    return 0;
}

 

写递归程序的关键在于：分类讨论。如果满足递归到最后一层的条件（递归进行到最后一步了），会怎么这么样；否则（不满足递归到最后一层的条件，正在前往最后一层的路上），直接调用递归程序（注意传参的变化）。