递归法思路：
 
树的高度即节点子树的高度+1（节点子树的高度即左子树高度，右子树高度的最大值）
 
代码如下：
 
// Height_Recursive 递归法求树的高度
int Height_Recursive(TreeNode* pTree) {
    if (pTree == NULL) 
    {
        return 0;
    }
    // 分别求出左子树,右子树的高度,取最大值+1
    int leftHeight = Height_Recursive(pTree->left);
    int rightHeight = Height_Recursive(pTree->right);
    return (leftHeight > rightHeight ? leftHeight: rightHeight)+1;
}
 
非递归法思路：
 
借鉴程序遍历的思想，一层层的遍历，累加层数即可得到树的高度
 
代码如下：
 
// Height_No_Recursive 非递归法求树的高度
// 思路:借鉴层序遍历的思想,一层层的遍历,层数即高度
int Height_No_Recursive(TreeNode* pTree) {
    if (pTree == NULL) 
    {
        return 0;
    }
    queue<TreeNode*> que;
    que.push(pTree);
    int height = 0;
    TreeNode* p = NULL;
    while(!que.empty())
    {
        height++;
        // 该层的节点个数,压入所有节点的孩子节点
        int num = que.size();
        for (int i=0;i<num;i++)
        {
            p = que.front();
            que.pop();

            if (p->left != NULL)
            {
                que.push(p->left);
            }
            if (p->right != NULL)
            {
                que.push(p->right);
            }
        }
    }
    return height;
}
 
实验结果如下图：
 
 
完整代码如下：
 
#include<iostream>
#include<queue>
using namespace std;

// 树(节点)定义
struct TreeNode 
{
	int		    data; // 值
	TreeNode*	left; // 左节点
	TreeNode*	right;// 右节点
};

// 按照前序建立二叉树，这里我们建立下面的树
//			8
//		6		10
//	  4	  7			12
//                11
// 所以输入顺序是：8 6 4 0 0 7 0 0 10 0 12 11 0 0 0
void createTree(TreeNode*& t)
{	
	cout<<"请输入数据："<<endl;
	int val = 0;
	cin>>val;
 
	// 0表结束
	if (0 == val)
	{
		t = NULL;
	}
	else 
	{
		t = new TreeNode();
		t->data = val;
		cout<<"开始建立:"<<val<<"的左节点：";
		createTree(t->left);
		cout<<"开始建立:"<<val<<"右节点：";
		createTree(t->right);
	}
}

// Height_Recursive 递归法求树的高度
int Height_Recursive(TreeNode* pTree) {
    if (pTree == NULL) 
    {
        return 0;
    }
    // 分别求出左子树,右子树的高度,取最大值+1
    int leftHeight = Height_Recursive(pTree->left);
    int rightHeight = Height_Recursive(pTree->right);
    return (leftHeight > rightHeight ? leftHeight: rightHeight)+1;
}

// Height_No_Recursive 非递归法求树的高度
// 思路:借鉴层序遍历的思想,一层层的遍历,层数即高度
int Height_No_Recursive(TreeNode* pTree) {
    if (pTree == NULL) 
    {
        return 0;
    }
    queue<TreeNode*> que;
    que.push(pTree);
    int height = 0;
    TreeNode* p = NULL;
    while(!que.empty())
    {
        height++;
        // 该层的节点个数,压入所有节点的孩子节点
        int num = que.size();
        for (int i=0;i<num;i++)
        {
            p = que.front();
            que.pop();

            if (p->left != NULL)
            {
                que.push(p->left);
            }
            if (p->right != NULL)
            {
                que.push(p->right);
            }
        }
    }
    return height;
}

int main()
{
    TreeNode* pTree = NULL;
	createTree(pTree);

    cout<<"\n递归法求树的高度"<<endl;
    cout<<Height_Recursive(pTree)<<endl;
   
    cout<<"\n非递归法求树的高度"<<endl;
    cout<<Height_No_Recursive(pTree)<<endl;

    return 0;
}
 
 

C语言 递归法求阶乘
 
利用一个函数进行递归求阶乘，但该数不能小于0，且若为0或1，得到的结果都为1，其他情况，对该数不断递归
 
#include <stdio.h>
#include <stdlib.h>
int main()
{
	int fac(int n);              // 函数声明
	int n;             //声明要阶乘的数为int型
	int y;             //声明结果为int型
	printf("Please input an integer numbers:");
	scanf("%d",&n);              // 输入要阶乘的数
	y=fac(n);
	printf("%d!=%d\n",n,y);
	system("pause");
	return 0;
}

int fac(int n)                // 定义fac函数
{
	int f;
	if(n<0)                     // n不能小于0
		printf("n<0,data error!");
	else if( n==0 || n==1)         // n=0 or n=1 ，阶乘都为1
		f=1;
	else f=fac(n-1)*n;           // n>1时，n!=n*(n-1)
	return(f);
}
//递归法求阶乘

最近在leetcode看到一道反转单链表的题，题目难度并不大，但是提交成功之后，看了官方给的递归版本的答案，觉得有点意思。以下是题目和代码，和大家分享一下
 
 下图是题目模板以及我自己写的代码（迭代法，和官方给的比起来就有点捞了）
 
 以下是官方给的迭代法以及递归的标准答案
 
 
 关于递归版本的答案，我再此陈述一下自己的理解。
 这一部分是递归跳出的条件，跳出时说明已到尾节点
 
if(head == null||head.next == null){
            return head;
        }
 
这一部分只是记录反转后的头结点及反准之前的尾节点。
 
 Node p = reverseList(head.next);
 
这部分是核心，当递归第一次return时，返回的时尾节点，及此时的p是尾节点（及p接受的是最后一层的返回值），但是在此时的代码体中的head是尾节点的前一个节点，这部分代码意思是将此时head节点的下一个节点指向自己（及反转），再将自己的next值为null，这里置为null是为了切断该节点与前一个节点之间的联系，并且避免循环的产生（当链表长度为2时，这里若不值为空，则会产生一个循环链表，并使代码进入死循环）。
 
 head.next.next = head;
        head.next = null;

递推法
 
#include<stdio.h>
int main()
{
	int n,y=1,i;
	scanf("%d",&n);
	if(n==0||n==1) y=1;//n是0或1的时候阶乘都是1 
	else for( i=1;i<=n;i++)//从1开始乘，一直乘到n 
	{
		y=i*y;//每次让i乘他前面数的阶乘 
	}
	printf("%d!=%d",n,y);
	return 0;
	 } 
 
递归法
 
//函数的递归使用 
#include<stdio.h>
int ff(int n)
{
	long f;
	if(n<0) printf("n<0,input error");
	else if(n==0||n==1) f=1;
	else f=ff(n-1)*n;
	return (f);
 } 
 int main()
 {
 	int n;
 	long y;
 	printf("input a int eager number:\n");
 	scanf("%d",&n);
 	y=ff(n);
 	printf("%d!=%ld",n,y);
 	return 0;
 	
 }