Get二叉树的最大深度

Get二叉树的最大/最小深度

注：本题来自LeetCode104

问题描述

给定一个二叉树，找出其最大深度。

最大深度是从根节点到最近叶子节点的最长路径上的节点数量。

说明: 叶子节点是指没有子节点的节点

示例

给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 （3->9）

核心代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root==null) return 0 ;

        int leftHeight = maxDepth(root.left) ; 
        int rightHeight = maxDepth(root.right) ; 
        
        return Math.max(leftHeight,rightHeight)+1 ;
        //若求最小深度，则把max改为min
    }
}

• 递归在二叉树这种数据结构中，是最常用的算法，几乎任何有关二叉树的操作，都可以用递归去解决，本题就是利用递归，走到树的所有叶子节点，再由自底向上的思想，从叶子节点自上逐层返回节点个数（深度）

• DFS深度优先搜索的应用

性能分析

• 时间复杂度：每个结点只会被访问到一次，故时间复杂度为O（N）
• 空间复杂度：考虑最糟糕的情况下，树是完全不平衡的，例如每个结点只剩下左子结点，递归将会被调用 N次（树的高度），因此保持调用栈的存储将是 O(N)。但在最好的情况下（树是完全平衡的），树的高度将是 log(N)。因此，在这种情况下的空间复杂度为O(log(N))

==========update by 2020 4/16 ========

C++可运行源代码（经VS2015/devC++编译运行通过）

#include "string.h"
#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 100 /* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
int count = 1;
						/* 用于构造二叉树********************************** */
int index = 1;
int index1 = 1;
typedef char String[100]; /*  0号单元存放串的长度 */
String str, str1;

/*分配字符串*/
Status StrAssign(String T, char *chars)
{
	int i;
	/*strlen计算字符串的长度*/
	if (strlen(chars)>MAXSIZE)
		return ERROR;
	else
	{
		T[0] = strlen(chars);
		for (i = 1; i <= T[0]; i++)
			T[i] = *(chars + i - 1);
		return OK;
	}
}
/* ************************************************ */

typedef char TElemType;
TElemType Nil = ' '; /* 字符型以空格符为空 */

					 /*访问结点*/
Status visit(TElemType e)
{
	printf("%c ", e);
	return OK;
}

typedef struct BiTNode  /* 结点结构 */
{
	TElemType data;		/* 结点数据 */
	struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
}BiTNode, *BiTree;


/* 构造空二叉树T */
Status InitBiTree(BiTree *T)
{
	*T = NULL;
	return OK;
}

/* 初始条件: 二叉树T存在。操作结果: 销毁二叉树T */
void DestroyBiTree(BiTree *T)
{
	if (*T)
	{
		if ((*T)->lchild) /* 有左孩子 */
			DestroyBiTree(&(*T)->lchild); /* 销毁左孩子子树 */
		if ((*T)->rchild) /* 有右孩子 */
			DestroyBiTree(&(*T)->rchild); /* 销毁右孩子子树 */
		free(*T); /* 释放根结点 */
		*T = NULL; /* 空指针赋0 */
	}
}

/* 按前序输入二叉树中结点的值（一个字符） */
/* #表示空树，构造二叉链表表示二叉树T。 */
void CreateBiTree(BiTree *T)
{
	TElemType ch;

	/* scanf("%c",&ch); */
	ch = str[index++];

	/*左右子树切换*/
	if (ch == '#')
		*T = NULL;
	else
	{
		/*生成树结点*/
		*T = (BiTree)malloc(sizeof(BiTNode));
		/*if (!*T)
		exit(OVERFLOW);*/
		(*T)->data = ch; /* 给结点赋值 */

						 /*递归创建左右子树*/
		CreateBiTree(&(*T)->lchild); /* 构造左子树 */
		CreateBiTree(&(*T)->rchild); /* 构造右子树 */
	}
}





/* 后续遍历思想，单参数传递的时间复杂度大于双参数传递，但更简洁
*此题可得到： 对称/相同二叉树-->判断-->涉及两颗二叉树-->适用双参递归
*左右子树深度比较-->单树比较-->比较-->单参数
*/
int BiTreeDepth(BiTree T)
{
	int i, j;
	/*判空*/
	if (!T)
		return 0;
	/*循环左*/
	if (T->lchild){	
		i = BiTreeDepth(T->lchild);
	}
	else {i = 0;}
	/*循环右*/
	if (T->rchild) {
		j = BiTreeDepth(T->rchild);
	}
	else {j = 0;}
	/*出口*/ /*若求最大深度，<改成>*/
	return i<j ? i + 1 : j + 1;
}


int main()
{
	int i;
	BiTree T;
	TElemType e1;


	/*初始化二叉树*/
	InitBiTree(&T);

	/*分配字符串*str=string，目的利用字符串给二叉树赋值*/
	/*前序输入，若不按规则输入，将报异常*/
	/*#代表空结点*/
	//StrAssign(str, "ABC##D##BD##C##");
//	StrAssign(str, "ABCD####E##");
	StrAssign(str, "ABCA###DA###BDAA###B##C#A##");

	/*创建二叉树*/
	CreateBiTree(&T);

	int d = BiTreeDepth(T); 
	printf("%d", d);

	//DispBtree(T); 
	system("pause");
}

运行结果