数据结构---二叉树（树和二叉树的基本概念、堆的概念和堆的实现、堆排序、二叉树的顺序和链式结构及其实现、相关面试题解析）

一、树和二叉树的基本概念和结构

1.树的基本概念和结构

树：树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

树的根节点：如果一颗树中的某个节点没有前节点，就称该节点为树的前驱节点。一棵树中有且仅有一个跟节点。

树的特点：树的任何一颗子树都是互不相交的；除了根节点以外，每个节点有且仅有一个父节点；一棵N个节点的树有N-1条边。

1）树的相关概念（蓝色字体为重点）

节点的度：一个节点含有子节点的个数，称为节点的度。（叶子节点的度为0）

叶节点（终端节点）：度为0的节点称为叶子节点或终端节点。

非终端节点（分支节点）：度不为0的节点称为非终端节点或分支节点。

双亲节点（父节点）：如果一个节点含有的子节点不为0，则该节点称为其子节点的双亲节点，又称父节点。

孩子节点（子节点）：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点。

兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点。

树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6

节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度：树中节点的最大层次；如上图：树的高度为4

堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点

节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

森林：由m（m>0）棵互不相交的树的集合称为森林；

2）树的表示（了解）

树的表示方法有很多种，如双亲表示法，孩子表示法、孩子兄弟表示法等。这里简单了解孩子兄弟表示法，孩子兄弟表示法也是树的最常用的表示方法。

typedef int DataType;

struct Node

{

struct Node * _firstChild1 ; // 第一个孩子结点

struct Node * _pNextBrother ; // 指向其下一个兄弟结点

DataType _data ; // 结点中的数据域

};

3）树的应用举例：计算机中文件系统结构就是一个树形结构

2.二叉树的基本概念和结构

二叉树：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成；这棵树的所有节点的度小于等于2。

二叉树的特点：每个结点最多有两棵子树，即二叉树不存在度大于2的结点；二叉树的子树有左右之分，其子树的次序不能颠倒。

1）二叉树和特殊的二叉树

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。（除叶子节点外其余节点的度均为2的二叉树称为满二叉树）

完全二叉树（重点）：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。（除最后一个非叶子节点的度为1外，其余非叶子节点的度均为2）

3）二叉树的性质（重点）

①若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.

②若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h- 1.

③对任何一棵二叉树, 如果度为0的叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0＝n2＋1

④若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=Log2(n+1). (ps：Log2(n+1)是log以2为底，n+1为对数)

⑤对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点

若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子

若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

3）二叉树的存储结构（了解）

二叉树的存储结构有顺序存储和链式存储两种，顺序存储一般使用数组进行存储，一般情况下顺序存储只适合于满二叉树或者完全二叉树的存储。二叉树的链式存储的两种存储结构定义如下：

// 二叉链

struct BinaryTreeNode

{

struct BinTreeNode * _pLeft ; // 指向当前节点左孩子

struct BinTreeNode * _pRight ; // 指向当前节点右孩子

BTDataType _data ; // 当前节点值域

}

// 三叉链

struct BinaryTreeNode

{

struct BinTreeNode * _pParent ; // 指向当前节点的双亲

struct BinTreeNode * _pLeft ; // 指向当前节点左孩子

struct BinTreeNode * _pRight ; // 指向当前节点右孩子

BTDataType _data ; // 当前节点值域

} ；

二、二叉树的顺序结构的实现---堆的概念及实现

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆 ( 一种二叉树 ) 使用顺序结构的数组来存储，需

注意的是这里的堆和操作系统 虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

1.堆的概念及结构

如果有一个关键码的集合 K = {k0 ， k1 ， k2 ， … ， kn-1} ，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2 i+1 且 Ki<= K2 i+2 (Ki >= K2 i+1 且 Ki >= K2 i+2) i = 0 ， 1 ， 2… ，则称为小堆( 或大堆 ) 。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质： 堆中某个节点的值总是不大于或不小于其父节点的值；堆是一棵完全二叉树。

2.堆的实现（向下调整算法、向上调整算法、堆的实现）

1）重点接口的解释

①向下调整算法

算法作用：将一个根节点的左右孩子均为大堆（小堆）的完全二叉树（非堆）堆调整成大堆（小堆）。

前提条件：对于大堆，根节点的左右孩子都必须是一个大堆；对于小堆，根节点的左右孩子都必须是小堆。

算法思路：根节点和较小（较大）的孩子进行比较，如果根节点小于（大于）孩子节点，则交换位置，如此迭代。

②向上调整算法

作用：向堆中插入一个数据可以使用向上调整算法实现。

在向堆中插入一个数据时，如果将要插入的数据放在数组下标为0的位置利用向下调整算法进行调整，则需要将数组整体后移，当堆较大时这样做就会有较大的性能损耗。使用向上调整算法的思路是将要插入的数据放在数组尾部，进行向上调整。

③构建堆

思路：从第一个非叶子结点开始向上迭代，利用向下调整算法创建。

最后一个非叶子节点的计算：假设一共有n个节点，最后一个节点的小标为n-1,最后一个非叶子节点就是最后一个节点的父节点，因此，最后一个非叶子节点的下标为：（n-2）/2;

2）接口定义

typedef int HPDataType;
typedef struct Heap
{
   HPDataType* _a;
   int _size;
   int _capacity;
}Heap;

//向下调整算法
void HeapAdjustDown(HPDataType* a, int root, int n);
//向上调整算法，小堆
void HeapAdjustUp(HPDataType* a, int child);
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);

3）接口的实现

//向下调整算法,小堆
void HeapAdjustDown(HPDataType* a,int root,int n)
{
    /*从根节点开始，将父节点跟子节点进行比较，如果根节点小于最小的子节点则交换两个节点继续迭代*/
	int parent = root;
	int child = 2 * parent + 1;
	while (child < n)
	{
		//如果右孩子节点存在，使child为左右孩子中较小的节点
		if (child + 1 < n && a[child] > a[child + 1])
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			//交换节点
			int temp = a[child];
			a[child] = a[parent];
			a[parent] = temp;
			//让父节点继续向下迭代
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}
//向上调整算法，小堆
void HeapAdjustUp(HPDataType* a, int child)
{
	int parent = (child - 2) / 2;
	//从最后一个叶子节点开始向上调整
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			//交换节点
			int temp = a[child];
			a[child] = a[parent];
			a[parent] = temp;
		}
		else
		{
			break;
		}
		child = parent;
		parent = (child-2) / 2;
	}
}
// 堆的构建小堆
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	//开辟空间
	hp->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
	hp->_size = hp->_capacity = n;
	//复制数组
	memcpy(hp->_a,a,sizeof(HPDataType)*n);
	//使用向下调整算法构建堆,从第一个非叶子节点开始向上依次对所有节点使用向下调整算法。
	//第一个非叶子节点也就是最后一个叶子节点的父节点，最后一个叶子节点的下标为:hp->_size-1，其父节点为：(hp->_size - 1 - 1)/2
	for (int i = (hp->_size - 2) / 2; i >= 0; i--)
	{
		HeapAdjustDown(hp->_a,i,hp->_size);
	}
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->_a);
	hp->_a = NULL;
	hp->_capacity = hp->_size = 0;
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
    /*向堆尾插入一个节点，使用向上调整算法进行调整*/
	assert(hp);
	if (hp->_capacity == hp->_size)
	{
		hp->_capacity++;
		hp->_a = (HPDataType*)realloc(hp->_a,sizeof(HPDataType)*(hp->_capacity));
	}
	hp->_a[hp->_size] = x;
	hp->_size++;
	//使用向上调整算法调整堆
	HeapAdjustUp(hp->_a,hp->_size-1);
}
// 堆的删除
void HeapPop(Heap* hp)
{
    //将最后一个节点和跟节点进行交换，将除去最后一个节点的新堆重新使用向下调整算法进行调整
	//堆顶元素与最后一个叶子节点交换，对堆重新进行向下调整
	assert(hp);
	int temp = hp->_a[hp->_size - 1];
	hp->_a[hp->_size - 1] = hp->_a[0];
	hp->_a[0] = temp;
	//堆大小减1
	hp->_size--;
	//向下调整算法对堆进行调整
	HeapAdjustDown(hp->_a,0,hp->_size);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	//如果堆为空返回-1.否则返回堆顶元素
	assert(hp);
	if (hp->_a == NULL)
	{
		return -1;
	}
	return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
	//如果堆为空返回非0的值，否则返回0
	return !(hp->_size);
}

3.堆排序（重点）

思路：将堆顶元素与最后一个节点进行交换，将新堆（除最后一个非叶子外的节点组成一个新堆）使用向下调整算法进行调整，依次迭代。

注意：排升序建大堆，排降序建小堆。

时间复杂度：O(N*logN)

特点：升序排序建大堆，降序排序建小堆。

// 对数组进行堆排序
void HeapSort(int* a, int n)
{
	//新堆的大小
	int size = n;
	//将数组调整成堆
	for (int i = (n- 2) / 2; i >= 0; i--)
	{
		HeapAdjustDown(a, i, n);
	}
	while (size - 1)
	{
		//交换堆的根节点和最后一个叶子节点
		int temp = a[0];
		a[0] = a[size - 1];
		a[size - 1] = temp;
		size--;
		//使用向下调整算法对堆进行调整
		HeapAdjustDown(a, 0, size);
	}
}

4.TopK问题

TopK问题是求一组数据中的前K大（前K小）个数问题，当这一组数据特别大以致内存无法存储下这些数据时，使用堆排序在选出前K个的方法就不在适用了。

解题思路：以求前K个大数时，构建一个含有K个节点的小堆，遍历所有数据与堆顶数据进行比较，如果有大于堆顶的数就将堆顶的数替换掉在使用向下调整算法对堆进行调整，依次迭代，直至所有数据都遍历完，含有K个节点的堆就是前K大个数。

注意：选择前K大个数构建小堆，选择前K小个数构建大堆。

代码描述：

void PrintTopK(int* a, int n, int k)
{
	//从a中取K个数建立含有K个数的小堆
	int* topK = (int*)malloc(sizeof(int)*k);
	memcpy(topK,a,sizeof(int)*k);
	//使用向下调整算法构建小堆
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		HeapAdjustDown(topK, i, k);
	}
	//遍历原数组，如果数组中的元素大于堆顶元素就进行替换
	for (int i = k; i < n; i++)
	{
		if (a[i] > topK[0])
		{
			topK[0] = a[i];
			//调整堆
			HeapAdjustDown(topK,0,k);
		}
	}
	printf("\n前K大个数为:");
	for (int i = 0; i < k; i++)
		printf("%d ",topK[i]);
	printf("\n");
}

三、二叉树的链式结构及其实现

结构定义

struct TreeNode {

    int val;//节点值

    struct TreeNode *left;//左孩子节点

   struct TreeNode *right;//右孩子节点

};

二叉树的链式结构主要依赖递归来实现，同时二叉树的增删查改在实际问题中并不常用，二叉树的主要用处在于搜索二叉树。

1.接口定义

typedef char BTDataType;
typedef struct BinaryTreeNode
{
   BTDataType _data;
   struct BinaryTreeNode* _left;
   struct BinaryTreeNode* _right;
}BTNode;

//队列操作
typedef struct QueueNode
{
   BTNode* _data;
   struct QueueNode* _next;
}QueueNode;
typedef struct Queue
{
   QueueNode* front;
   QueueNode* rear;
}Queue;

//初始化队列
void QueueInit(Queue* q);
//进队
void QueuePush(Queue* q, BTNode* node);
//出队
void QueuePop(Queue* q);
//判队空
bool QueueIsEmpty(Queue* q);

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

2.接口实现

//初始化队列
void QueueInit(Queue* q)
{
	assert(q);
	q->front = NULL;
	q->rear = NULL;
}
//进队
void QueuePush(Queue* q, BTNode* node)
{
	assert(q);
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	newNode->_data = node;
	newNode->_next = NULL;
	//如果队列为空，则队头队尾指向该节点
	if (q->front == NULL)
		q->front = q->rear = newNode;
	else
	{
		q->rear->_next = newNode;
		q->rear = newNode;
	}
}
//出队
void QueuePop(Queue* q)
{
	assert(q);
	if (q->front == NULL)
	{
		printf("空队列，无法进行出队操作\n");
		return;
	}
	QueueNode* del = q->front;
	q->front = q->front->_next;
	free(del);
}
//判队空
bool QueueIsEmpty(Queue* q)
{
	assert(q);
	return !(q->front);
}

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	/*注意：序列中#表示NULL*/
	//如果为NULL，返回空，如果不为NULL，创建节点及其左右孩子
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}
	struct BinaryTreeNode* root = (BTNode*)malloc(sizeof(BTNode));
	//BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	root->_data = a[*pi];
	(*pi)++;
	root->_left = BinaryTreeCreate(a, pi);
	root->_right = BinaryTreeCreate(a, pi);

	return root;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	//后序遍历二叉树，先删除左右孩子树在删除根节点
	if (*root == NULL)
		return;
	BinaryTreeDestory(&(*root)->_left);
	BinaryTreeDestory(&(*root)->_right);
	free(*root);
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	//遍历二叉树，如果节点为NULL，返回0；如果不为NULL，则二叉树节点个数的1+左右子节点个数
	if (root == NULL)
		return 0;
	return 1 + BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right);
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	//二叉树的叶子节点个数 = 左子树节叶子节点个数 + 右子树叶子节点个数
	//如果为空树，叶子节点个数为0，如果一个节点的左右子树都为空树，则叶子节点个数为1，否则就等于左子树+右子树叶子节点个数
	if (root == NULL)
		return 0;
	if (root->_left == NULL && root->_right == NULL)
		return 1;
	return BinaryTreeLeafSize(root->_left)+BinaryTreeLeafSize(root->_right);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	//求二叉树第k层节点个数可以分解为：当层数为第2层时求第k-1层...依次递归，直到k=1表示当前层节点个数
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;
	k--;
	return BinaryTreeLevelKSize(root->_left, k) + BinaryTreeLevelKSize(root->_right,k);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	//如果是一个空树，返回NULL；如果不是空树，判断根节点如果是要查找的值就返回跟节点，如果根节点不是则判断左右子树中是否存在
	if (root == NULL)
		return NULL;
	if (root->_data == x)
		return root;
	if (BinaryTreeFind(root->_left, x) == NULL)
		return BinaryTreeFind(root->_right,x);
	return NULL;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
		return;
	printf("%c ",root->_data);
	BinaryTreePrevOrder(root->_left);
	BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeInOrder(root->_left);
	printf("%c ", root->_data);
	BinaryTreeInOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreePostOrder(root->_left);
	BinaryTreePostOrder(root->_right);
	printf("%c ", root->_data);
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	//让跟节点入队，在出队，出队时让其左右孩子入队，依次递归
	if (root == NULL)
		return;
	struct Queue q;
	QueueInit(&q);
	QueuePush(&q,root);
	while (!QueueIsEmpty(&q))
	{
		if (q.front->_data == NULL)
		{
			//如果队列的节点值为NULL，直接出队即可
			QueuePop(&q);
		}
		else
		{
			//让队列的头结点出队，让其左右孩子节点入队
			printf("%c ",q.front->_data->_data);
			QueuePush(&q,q.front->_data->_left);
			QueuePush(&q,q.front->_data->_right);
			QueuePop(&q);
		}
	}
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	//层序遍历二叉树，当队列中的节点为NULL时停止，查看队列中的节点是否全为NULL，如果是则是完全二叉树，否则不是
	if (root == NULL)
		return true;
	struct Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	while (!QueueIsEmpty(&q))
	{
		if (q.front->_data == NULL)
		{
			//如果队列的节点值为NULL，直接出队即可
			break;
		}
		else
		{
			//让队列的头结点出队，让其左右孩子节点入队
			QueuePush(&q, q.front->_data->_left);
			QueuePush(&q, q.front->_data->_right);
			QueuePop(&q);
		}
	}
	//判断队列中剩余的节点是否全为NULL
	while (!QueueIsEmpty(&q))
	{
		if (q.front->_data != NULL)
			return false;
		else
		{
			QueuePop(&q);
		}
	}
	return true;
}

四、二叉树链式结构相关题目及解析（leetcode、牛客）

1.单值二叉树：https://leetcode-cn.com/problems/univalued-binary-tree/

bool isUnivalTree(struct TreeNode* root){
    if(root == NULL)
        return true;
    //如果左右孩子的值不等于根节点的值，不是单值二叉树，返回false
    if(root->left && root->left->val != root->val)
        return false;
    if(root->right && root->right->val != root->val)
        return false;
    
    //二叉树的左右子树都是单值二叉树时，该二叉树才是单值二叉树
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

2.二叉树最大深度：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

int maxDepth(struct TreeNode* root){
    //二叉树的最大深度等于左右子树的最大深度+1
    if(root == NULL)
        return 0;
    
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);

    return leftDepth>rightDepth?(leftDepth+1):(rightDepth+1);
}

3.翻转二叉树：https://leetcode-cn.com/problems/invert-binary-tree/

//方法1
struct TreeNode* invertTree(struct TreeNode* root){
    if(root == NULL)
        return NULL;
    
    //翻转左右孩子节点
    struct TreeNode* right = root->right;
    root->right = root->left;
    root->left = right;
    invertTree(root->right);
    invertTree(root->left);
    return root;
}
//方法2
struct TreeNode* invertTree(struct TreeNode* root){
    if(root == NULL)
        return NULL;
    
    //翻转左右孩子节点
    struct TreeNode* right = root->right;
    root->right = invertTree(root->left);
    root->left = invertTree(right);
    return root;
}

4.相同的树：https://leetcode-cn.com/problems/same-tree/

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if(p == NULL && q == NULL)
    {
        //结构相同
        return true;
    }

    //结构不同
    if(p == NULL && q != NULL)
        return false;
    if(p != NULL && q == NULL)
        return false;
    //值不同
    if(p->val != q->val)
        return false;
    
    //
    return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
}

5.对称二叉树：https://leetcode-cn.com/problems/symmetric-tree/

void invertTree(struct TreeNode* root)
{
    if(root == NULL)
        return;
    struct TreeNode* right = root->right;
    root->right = root->left;
    root->left = right;
    invertTree(root->left);
    invertTree(root->right);
}
bool isSameTree(struct TreeNode* s,struct TreeNode* t)
{
    if(s == NULL && t == NULL)
        return true;
    if(s == NULL && t != NULL)
        return false;
    if(s != NULL && t == NULL)
        return false;
    if(s->val != t->val)
        return false;

    return isSameTree(s->left,t->left)&&isSameTree(s->right,t->right);
}
bool isSymmetric(struct TreeNode* root){
    if(root == NULL)
        return true;
    //对左子树进行翻转，判断与右子树是否相等
    invertTree(root->left);
    return isSameTree(root->left,root->right);
}

6.二叉树的前序遍历：https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

int TreeSize(struct TreeNode* root)
 {
    if(root == NULL)
        return 0;
    return 1+TreeSize(root->left)+TreeSize(root->right);
 }
void _preorderTraversal(struct TreeNode* root,int* ret,int*index)
{
    if(root == NULL)
        return;
    
    //保存根节点继续遍历左右子树
    ret[(*index)++] = root->val;
    _preorderTraversal(root->left,ret,index);
    _preorderTraversal(root->right,ret,index);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    //开辟数组空间
    int* ret = (int*)malloc(sizeof(int)*size);
    //递归遍历，存入数组
    int index = 0;//数组下标
    *returnSize = size;
    _preorderTraversal(root,ret,&index);

    return ret;
}

7.二叉树的中序遍历：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

int TreeSize(struct TreeNode* root)
{
    if(root == NULL)
        return 0;
     return 1+TreeSize(root->left)+TreeSize(root->right);
}
void _inorderTraversal(struct TreeNode* root,int* ret,int* index)
{
    if(root == NULL)
        return;
    _inorderTraversal(root->left,ret,index);
    ret[(*index)++] = root->val;
    _inorderTraversal(root->right,ret,index);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    *returnSize = size;
    int* ret = (int*)malloc(sizeof(int)*size);
    //中序遍历
    int index = 0;
    _inorderTraversal(root,ret,&index);

    return ret;
}

8.二叉树的后序遍历：https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

int TreeSize(struct TreeNode* root)
{
    if(root == NULL)
        return 0;
    return 1+TreeSize(root->left)+TreeSize(root->right);
}
void _postorderTraversal(struct TreeNode* root,int* ret,int* index)
{
    if(root == NULL)
        return;
    
    _postorderTraversal(root->left,ret,index);
    _postorderTraversal(root->right,ret,index);
    ret[(*index)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    *returnSize = size;
    int* ret = (int*)malloc(sizeof(int)*size);

    int index = 0;
    _postorderTraversal(root,ret,&index);
    return ret;
}

9.另一个树的子树：https://leetcode-cn.com/problems/subtree-of-another-tree/

bool IsSameTree(struct TreeNode* s,struct TreeNode* t)
{
    if(s == NULL && t == NULL)
        return true;

    if(s == NULL && t != NULL)
        return false;
    if(s != NULL && t == NULL)
        return false;
    if(s->val != t->val)
        return false;

    return IsSameTree(s->left,t->left)&&IsSameTree(s->right,t->right);
}
bool isSubtree(struct TreeNode* s, struct TreeNode* t){
    if(s == NULL)
        return false;
    
    if(IsSameTree(s,t))
        return true;
    else
    {
        return isSubtree(s->left,t)||isSubtree(s->right,t);
    }
}

10.平衡二叉树：https://leetcode-cn.com/problems/balanced-binary-tree/submissions/

//方法1----时间复杂度O(N^2)
int TreeDepth(struct TreeNode* root)
{
    if(root == NULL)
        return 0;
    int left = TreeDepth(root->left);
    int right = TreeDepth(root->right);

    return left>right?(1+left):(1+right);
}
bool isBalanced(struct TreeNode* root){
    if(root == NULL)
        return true;
    int left = TreeDepth(root->left);
    int right = TreeDepth(root->right);
    if(left - right > 1 || left - right < -1)
        return false;

    return isBalanced(root->left)&&isBalanced(root->right);
}

//方法2----时间复杂度O(N)
bool _isBalanced(struct TreeNode* root,int* length)
{
    if(root == NULL)
    {
        *length = 0;
        return true;
    }
    //判断左子树是否为平衡二叉树
    int leftLength = 0;
    if(!_isBalanced(root->left,&leftLength))
        return false;
    //判断右子树是否为平衡二叉树
    int rightLenght = 0;
    if(!_isBalanced(root->right,&rightLenght))
        return false;
    if(abs(leftLength-rightLenght) > 1)
        return false;
    *length = leftLength>rightLenght?leftLength+1:rightLenght+1;
    return true;
}
bool isBalanced(struct TreeNode* root){
    int length = 0;
    return _isBalanced(root,&length);
}

11.(牛客网)二叉树的构建及遍历：https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

#include<stdio.h>
#include<stdlib.h>

typedef struct TreeNode
{
    char val;//节点值
    struct TreeNode* left;//左孩子
    struct TreeNode* right;//右孩子
}TreeNode;
    
TreeNode* CreateTree(char* str,int* i)
{
    if(str[*i] == '#')
    {
        (*i)++;
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = str[*i];
    (*i)++;
    root->left = CreateTree(str,i);
    root->right = CreateTree( str, i);
    return root;
}
void inorderTraversal(TreeNode* root)
{
    if(root == NULL)
        return;
    inorderTraversal(root->left);
    printf("%c ",root->val);
    inorderTraversal(root->right);
}
int main()
{
    int i = 0;
    char str[100];
    scanf("%s",str);
    TreeNode* root = NULL;
    root = CreateTree(str,&i);
    inorderTraversal(root);
    return 0;
}