LeetCode刷题笔记（四）——初级算法——树

最新推荐文章于 2023-06-04 15:00:00 发布

Mist_Orz

最新推荐文章于 2023-06-04 15:00:00 发布

阅读量331

点赞数 1

分类专栏： LeetCode刷题笔记文章标签： leetcode

本文链接：https://blog.csdn.net/ooorczgc/article/details/120661776

版权

LeetCode刷题笔记专栏收录该内容

7 篇文章 1 订阅

订阅专栏

二叉树的最大深度

在这里插入图片描述
我的思路：
其实刚在数据结构课程里看到这个题的解法，但是呢，知道方法不一定自己能敲出来，特别是如何去构造一个二叉树我还没有实践过。
首先我第一个想到的就是使用递归的方法建立二叉树，根据打印二叉树的方法，参考下面的文章我写了第一个版本
超全C语言二叉树基本操作及讲解

BiTree Creat_BiTree(int* inputArray, int n)
{
	static int i;
	if (inputArray[i] == null)
		return NULL;
	BiTNode* root = (BiTree)malloc(sizeof(BiTree));
	root->val = inputArray[i++];
	if (i < n)
	{
		root->left = Creat_BiTree(inputArray, n);
		root->right = Creat_BiTree(inputArray, n);
	}
	return root;
}

但是呢，leetcod给出的是用数组表示的二叉树，而用数组表示二叉树时，相当于二叉树的层序遍历，所以不能直接用这个函数，于是我又想，二叉树的层序遍历用的是队列，那我是不是可以用队列的方法来建立二叉树呢？
应该是可以的，但是我没想出来，然后看到了这位同学的文章
LeetCode二叉树构造方法，通过一维数组直接构建完整的二叉树（按照LeetCode的格式）
用的就是队列的方法，但是好复杂就没看懂。。。

于是我放弃了思考，又查了资料，终于找到了这位同学的文章
Leetcode中使用数组创建二叉树
非常简洁而且实用，原理是利用了数组二叉树中元素位置和下标的对应关系来建立二叉树，我以前一直想的都是顺序的读取数组，然后以此复制到二叉树中，思维有点局限了。
参考之下我的代码

//利用数组二叉树的下标对应关系简历链式二叉树
BiTree Creat_BiTree(int* inputArray, int n, int index)
{
	BiTNode* p = NULL;
	if (index < n && inputArray[index] != null)
	{
		p = (BiTree)malloc(sizeof(BiTNode));
		p->val = inputArray[index];
		p->left = Creat_BiTree(inputArray, n, 2 * index + 1);
		p->right = Creat_BiTree(inputArray, n, 2 * index + 2);
	}
	return p;
}

在调试过程中我遇到了一个问题
在使用malloc()函数分配内存的过程中报：“c.exe已触发了一个端点。”的错误。
在这里插入图片描述
在加入断点后发现，这个错误不是第一次调用时就会发生，而是在运行了几层递归后发生的，错误的原因；经过查资料基本断定是指针溢出之类的问题，但是具体为什么我百思不得其解。
在不断地查阅资料过程中这个问答给了我答案
malloc时触发断点
在这里插入图片描述
一言惊醒梦中人！

这样写的效果是申请了指针的空间，而正确的应该是申请结构体的内存空间。
改成
p = (BiTree)malloc(sizeof(BiTNode));
就没问题了。
完整的使用数组初始化二叉树的代码

//利用数组二叉树的下标对应关系简历链式二叉树
BiTree Creat_BiTree(int* inputArray, int n, int index)
{
	BiTNode* p = NULL;
	if (index < n && inputArray[index] != null)
	{
		p = (BiTree)malloc(sizeof(BiTNode));
		p->val = inputArray[index];
		p->left = Creat_BiTree(inputArray, n, 2 * index + 1);
		p->right = Creat_BiTree(inputArray, n, 2 * index + 2);
	}
	return p;
}

BiTree Init_BiTree(int* inputArray, int n)
{
	BiTNode* root = Creat_BiTree(inputArray, n, 0);
	return root;
}

建立了二叉树之后为了验证其正确性我又写了前序遍历打印二叉树的代码

void PrintBiTree(BiTree BT)
{
	if (BT)
	{
		printf("%d ", BT->val);
		PrintBiTree(BT->left);
		PrintBiTree(BT->right);
	}
}

然后本题的解答，因为之前看数据结构的课程里面有讲过，所以“参考”了一下

int maxDepth(struct TreeNode* root) {
	int max, maxL, maxR;
	if (root)
	{
		maxL = maxDepth(root->left);
		maxR = maxDepth(root->right);
		max = (maxL > maxR) ? maxL : maxR;
		return max + 1;
	}
	return 0;
}

在这里插入图片描述
然后我看了看答案，答案有两种解法，一种是和我的思路类似的“深度优先搜索”，另一种是看起来很复杂的“广度优先搜索”。然而。。。官方给出的答案只用了两行我去！！！

在这里插入图片描述

❤ 2021.10.9 ❤
今天的题目是：

验证二叉搜索树

在这里插入图片描述
我的思路：
看起来挺简单啊~
不就是每个分支的左边节点小于父节点，右边节点大于父节点嘛~
首先测试环境搭建

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

#define null -1

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

typedef struct TreeNode {
	int val;
	struct TreeNode* left;
	struct TreeNode* right;
}BiTNode,*BiTree;

BiTree Creat_BiTree(int* inputArray, int n, int index)
{
	BiTNode* p = NULL;
	if (index < n && inputArray[index] != null)
	{
		p = (BiTree)malloc(sizeof(BiTNode));
		p->val = inputArray[index];
		p->left = Creat_BiTree(inputArray, n, 2 * index + 1);
		p->right = Creat_BiTree(inputArray, n, 2 * index + 2);
	}
	return p;
}

BiTree Init_BiTree(int* inputArray, int n)
{
	BiTNode* root = Creat_BiTree(inputArray, n, 0);
	return root;
}

void PrintBiTree(BiTree T)
{
	if (T)
	{
		printf("%d ", T->val);
		PrintBiTree(T->left);
		PrintBiTree(T->right);
	}
}

bool isValidBST(struct TreeNode* root) {

}

int main()
{
	int a[] = { 2,1,3 };
	int b[] = { 5,1,4,null,null,3,6 };
	BiTree T = Init_BiTree(a, 3);
	PrintBiTree(T);
	printf("\n");
	bool x = isValidBST(T);
	printf("%d\n", x);

	BiTree K = Init_BiTree(b, 7);
	PrintBiTree(K);
	printf("\n");
	bool y = isValidBST(K);
	printf("%d\n", y);
}

然后我以为是轻车熟路，谁想到。。。。
首先，我假设每个父节点都有两个子节点的思路去写，后来一测试发现leetcode的测试样例中存在单边节点的情况，于是我稍作改进，写了如下代码

bool isValidBST1(struct TreeNode* root) {
	if ((root->left != NULL && (root->left->val >= root->val || !isValidBST(root->left))) || (root->right != NULL && (root->right->val <= root->val || !isValidBST(root->right))))
		return false;
	return true;
}

为了体现技术含量我特意把他写成了一行，但是测试发现，这样写无法应对类似于root = [5,1,4,null,null,3,6]这样隔层比较的情况，我看了别人的答案，可以在这个基础上增加阈值的判断，通过建立新函数将该分支的最大/最小值传入函数中，如果超过阈值同样返回false，以下是别人的答案
在这里插入图片描述
大概意思知道了，但是就觉得好麻烦，于是我换了另一种思路，用中序遍历的方法来实现。
中序遍历使用的也是递归的方法，在打印二叉树的时候很容易实现，但是既然要判断二叉搜索树就一定需要比较，根据本题的题意，在当前节点的值大于前一节点时为true，于是必须有一个变量来存储前一节点的数值。
我首先想到的是使用静态变量static int，但是我们知道，为了保证静态变量随递归函数运行而变化，是不能在声明中赋值的（大概是这样吧），而静态变量在声明时会自动初始化为0（见如下链接）
C 语言中 static 的作用
但是好巧不巧（或者说是故意的），leetcode的测试用例中恰好有一个[0]的例子，于是在第一轮递归判断中怎么也通不过。。。F***。。。
没办法，我只好修改程序，使用全局变量来实现

long pre = LONG_MIN;
bool isValidBST(struct TreeNode* root) {
	bool a = true, b = true, c = true;
	if (root)
	{
		a = isValidBST(root->left);
		b = pre < root->val;
		pre = root->val;
		c = isValidBST(root->right);
		return a && b && c;
	}
	return true;
}

注意这里的全局变量用的是long型，最开始我用的是int型，但是leetcode直接甩了一个[-2147483648]上来，我去。。。于是我把判断条件改成了第一步不判断，然后leetcode又甩上来这个[-2147483648,-2147483648]，我嘞个大去！！我才知道为啥别人的答案里用的都是long型了，我服。。。
除此之外我还遇到了个诡异的问题，同样的程序，我在vs里测试结果是对的，我在leetcode控制台里设置测试用例执行结果也是对的，但是一提交，相同的例子就告诉我结果不对？！后来我把相同的代码写在C++里，再一提交就没问题，所以得出结论，不是我的问题！
在这里插入图片描述

❤ 2021.1010 ❤
今天的题目是：

对称二叉树

在这里插入图片描述
我的思路：
有点乱有点乱，我能想到的方法是，先把二叉树中序遍历一遍，将各节点的数值储存在链表里，然后再按照之前判断链表是不是回文链表，以此来判断二叉树是否对称。
但是想一想好像有点太傻了，毕竟二叉树可是更高级的数据结构啊！
换一种思路。
既然我现在有根节点，我就能找到二叉树里面的任意一个节点，我只要遍历所有对称的节点的值是否相同就行。
但是怎么实现呢。。。还是没有思路，那就看看别人是怎么做的吧~
emmm。。。。说实话看答案都看不懂，不过有个老哥的思路值得借鉴，中序遍历是先左，再中，再右，对称二叉树的中序遍历结果一定是对称的，但是先左后右的方法实际上是人为规定的，如果我用先右，再中，再左的方法来遍历，整个遍历结果就是倒过来的，如果两种遍历方法的结果一样，那么这个二叉树一定是对称的。当然，为了避免枝节点只有一个叶的情况，另一个空缺的叶节点也要表示出来。
首先还是搭建测试环境，具体的代码就不贴了，
然后我用链表来存储二叉树遍历的值，定义了两个函数来将遍历结果存入链表中。

typedef struct LinkNode {
	int val;
	struct LinkNode* next;
}LNode,*LinkList;

LinkList Left, Right;
LNode* p1, * p2;

void LeftTraversal(struct TreeNode* T)
{
	if (T)
	{
		LeftTraversal(T->left);
		LNode* p = (LinkList)malloc(sizeof(LNode));
		p->val = T->val;
		p->next = NULL;
		p1->next = p;
		p1 = p;
		LeftTraversal(T->right);
	}
}

void RightTraversal(struct TreeNode* T)
{
	if (T)
	{
		RightTraversal(T->right);
		LNode* p = (LinkList)malloc(sizeof(LNode));
		p->val = T->val;
		p->next = NULL;
		p2->next = p;
		p2 = p;
		RightTraversal(T->left);
	}
}

然后判断的函数是这样的

bool isSymmetric(struct TreeNode* root) {
	RepairTree(root);
	Left = (LinkList)malloc(sizeof(LNode));
	Right = (LinkList)malloc(sizeof(LNode));
	p1 = Left;
	p2 = Right;
	LeftTraversal(root);
	RightTraversal(root);
	LNode* pl = Left->next;
	LNode* pr = Right->next;
	while (pl != NULL && pr != NULL)
	{
		if (pl->val != pr->val)
			return false;
		pl = pl->next;
		pr = pr->next;
	}
	return true;
}

测试没有问题，提交出问题了
在这里插入图片描述
这。。。真有才。。。这样的测试用例都能想到，好，我改，我把每个不完整的枝节点都补全，然后再判断，建立一个补全函数，给枝节点下面只有一个叶子的补上一个-1.

void RepairTree(struct TreeNode* T)
{
	if (T)
	{
		if (T->left != NULL && T->right == NULL)
		{
			struct TreeNode* p = (struct TreeNode*)malloc(sizeof(struct TreeNode));
			p->val = -1;
			p->left = NULL;
			p->right = NULL;
			T->right = p;
		}
		if (T->left == NULL && T->right != NULL)
		{
			struct TreeNode* p = (struct TreeNode*)malloc(sizeof(struct TreeNode));
			p->val = -1;
			p->left = NULL;
			p->right = NULL;
			T->left = p;
		}
		RepairTree(T->left);
		RepairTree(T->right);
	}
}

提交
在这里插入图片描述
一脸懵逼。。。这是什么神仙样例！
在我的补全函数作用下，这个树会变成这样

从左到右中序遍历的结果是一样的我嘞个去！神仙样例！
好吧，我被迫不得不看答案。。。
emmmm。。。看了答案之后，感觉我就是个傻子。。。

bool check(struct TreeNode* p, struct TreeNode* q)
{
	if (!p && !q)
		return true;
	if (!p || !q)
		return false;
	return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
}

bool isSymmetric(struct TreeNode* root) {
	return check(root, root);
}

一开始看答案我是没有看懂的，但是想了想就明白了，这个思路和我之前对称地去判断二叉树是不是对称是一样的。因为指针从一开始就指向了左右两半棵树，所以不存在跑到同一边的情况，而且每次递归的时候两个指针都是对称移动的，所以在每个check的流程中两个指针都处于对称的位置。
学到了学到了，看来我对递归的理解还是太浅薄。

❤ 2021.10.13 ❤
今天的题目是：

二叉树的层序遍历

在这里插入图片描述
我的思路是：
其实吧，二叉树的层序遍历在数据结构里面讲了，方法大概就是用队列，先将根节点存入队列，然后从头读取该队列，将第一个节点取出，并打印其数值，如果其子节点不为空，则将其存入队列，并继续读取队列。
但是这样打印出来的是一串值，而按题目的要求，需要将其按照所在层数存入二维数组中，于是怎么去判断一个节点在哪层呢？
一番思考之后我并没有想明白，于是不得不看了答案。。。
看了之后恍然大悟，原理其实很简单，其实层序遍历相对于使用递归方式的深度搜索方法（DFS）来说，叫做广度搜索方法（BFS），具体就是在队列操作时不是一个节点一个节点的处理，而是一口气读出一层的节点，然后处理完之后，再去读取下一层的节点，操作的方式就是读取队列之前先判断队列里面元素的个数，其就是一层节点的总数，然后将读到的数值打印出来，读到的子节点放入队列，这样在一层节点读取完后，队列里就是下一层节点的总数，依次循环。
嗯。。。说起来好想挺简单的。。。。
然后看了一下c语言版本的函数格式

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){

}

我去，这是什么东西。。。
一堆星星。。。
凭着我一个多月的刷题经验以及敏锐的直觉，我觉得开头的星星指的是返回值为一个二维数组，第一个参数是二叉树，第二个参数是一个隐式返回值，那第三个参数是啥。。。
根据参数的名字，我猜那是指的二维数组的列数，但是为啥有两个星星呢？进一步分析，因为返回值是二维数组，但是每层单元的数量是不一样的，所以要返回一个数组记录每层元素的数量。因此这个参数应该是一个隐式返回值数组！
这个答案讲解的就很明白，同时还讲解了最短路径问题，其实广度搜索就是解决最短路径问题的方法之一。
→→→ BFS 的使用场景总结：层序遍历、最短路径问题
心几次哇一次某黑他次！
在确定了参数及返回值之后，下面开始搭建测试环境以及主函数。
建立二叉树的函数和之前一样，主函数如下

int main()
{
	int a[] = { 3,9,20,null,null,15,7 };
	int returnSize;
	int* returnColumnSizes;
	BiTree T = InitBiTree(a, 7);
	//PrintBiTree(T);
	int** p = levelOrder(T, &returnSize, &returnColumnSizes);
	for (int i = 0; i < returnSize; i++)
	{
		printf("[");
		for (int j = 0; j < returnColumnSizes[i]; j++)
		{
			printf("%d ",p[i][j] );
		}
		printf("]\n");
	}
}

这里我想了半天，怎么建一个数组来接收返回值和隐式返回的各列长度呢？当时把二维数组作为参数传入函数我可是捣鼓了半天，后来想明白了，我只需要建立一个二维指针来接收二维数组的地址，至于内存分配和赋值是在函数里完成的，隐式返回值也是同样的道理，我只需要建立一个指向数组的指针，然后把指针的地址作为参数传递给函数，这也就是为什么形参类型是二重指针。
然后下面就是正式题解函数之前的准备工作，也就是搭建一套队列操作函数（c语言造轮子。。。）

#define ElementType BiTNode*

typedef struct Node
{
	ElementType data;
	struct Node* next;
}Node;

typedef struct QueueNode
{
	struct Node* front;
	struct Node* rear;
}QNode, * Queue;

Queue InitQueue()
{
	Queue q = (Queue)malloc(sizeof(QNode));
	q->front = NULL;
	q->rear = NULL;
	return q;
}

bool QueueEmpty(Queue Q)
{
	if (Q->front == NULL)
		return true;
	return false;
}

void EnQueue(Queue Q, ElementType value)
{
	if (value == NULL)
		return;
	Node* p = (Node*)malloc(sizeof(Node));
	p->data = value;
	p->next = NULL;
	if (QueueEmpty(Q))
	{
		Q->front = p;
		Q->rear = p;
	}
	else
	{
		Q->rear->next = p;
		Q->rear = p;
	}
}

ElementType DeQueue(Queue Q)
{
	Node* p = NULL;
	ElementType value = NULL;
	if (QueueEmpty(Q))
		return NULL;
	p = Q->front;
	value = Q->front->data;
	Q->front = Q->front->next;
	free(p);
	return value;
}

int QueueSize(Queue Q)
{
	Node* p = Q->front;
	int count = 0;
	while (p)
	{
		count++;
		p = p->next;
	}
	return count;
}

然后就是激动人心的解答函数环节了！不得不说用c语言写这道题的人还真的挺少，甚至官方答案里面都没有c语言的。。。于是我只好找了两篇其他人的答案作为参考
这位老哥的答案很值得借鉴，不过相对来说他使用的数组作为队列容器，比我用链表来存储代码相对简洁了一些。
→→→ C语言广度优先策略，借组指针数组模拟队列实现
我也是从他以及其他c语言解法中学到了怎么去构建动态二维数组的，不过这个方法有个小缺点，他从一开始就分配了一大块内存来存储返回值数组以及列数数组，这样对内存的使用率就下降了不少，其实可以使用动态再分配内存的方法，就是稍微再复杂了一些。
而且我觉得他的答案里面有一些变量其实是可以省掉的，于是我做了一些改进

int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
	int** result = (int**)malloc(sizeof(int) * Maxsize);	//	为返回值二维数组分配内存空间
	*returnColumnSizes = (int*)malloc(sizeof(int) * Maxsize);	//为隐式返回值二维数组的列数数组分配内存空间
	*returnSize = 0;	//返回值二维数组从第0行开始
	if (root == NULL)
		return NULL;
	Queue q = InitQueue();	//新建队列
	EnQueue(q, root);	//将root节点放入队列
	while (!QueueEmpty(q))	//判断队列是否为空，队列为空即表示二叉树已遍历结束
	{
		(*returnColumnSizes)[*returnSize] = QueueSize(q);	//将队列长度（也就是本层节点数量）赋值给列数数组
		result[*returnSize] = (int*)malloc(sizeof(int) * (*returnColumnSizes)[*returnSize]);	//为本行返回值数组分配内存空间【是在开头分配的空间里面再分配么？】
		for (int i = 0; i < (*returnColumnSizes)[*returnSize]; i++)	//循环遍历队列元素，将数值赋给返回值数组，将子节点放入队列。
		{
			BiTNode* p = DeQueue(q);
			result[*returnSize][i] = p->val;
			if (p->left)
				EnQueue(q, p->left);
			if (p->right)
				EnQueue(q, p->right);
		}
		(*returnSize)++;	//行数加1
	}
	return result;
}

在这里插入图片描述
成绩还可以吧。
然后我又尝试了用c++来实现，不得不说，C++调用库函数果然简单了很多。。。
下面是完整的测试环境加解答函数

#include <iostream>
#include <vector>
#include <queue>

#define null -1

using namespace std;

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};

class BiTree 
{
private:
    TreeNode* CreatBiTree(vector<int> inputArray, int index)
    {
        TreeNode* T = nullptr;
        if (index < inputArray.size() && inputArray[index] != null)
        {
            T = new TreeNode(inputArray[index]);
            T->left = CreatBiTree(inputArray, 2 * index + 1);
            T->right = CreatBiTree(inputArray, 2 * index + 2);
        }
        return T;
    }

public:
    TreeNode* InitBiTree(vector<int> inputArray)
    {
        TreeNode* root = CreatBiTree(inputArray, 0);
        return root;
    }

    void PrintBiTree(TreeNode* T)
    {
        if (T)
        {
            printf("%d ", T->val);
            PrintBiTree(T->left);
            PrintBiTree(T->right);
        }
    }
};

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if (root == nullptr)
            return result;
        int level = 0;
        int levelsize = 0;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty())
        {
            levelsize = q.size();
            result.push_back(vector<int>());
            for (int i = 0; i < levelsize; i++)
            {
                result.back().push_back(q.front()->val);
                if (q.front()->left != nullptr)
                    q.push(q.front()->left);
                if (q.front()->right != nullptr)
                    q.push(q.front()->right);
                q.pop();
            }
            level++;
        }
        return result;
    }

    void PrintResult(vector<vector<int>> p)
    {
        for (int i = 0; i < p.size(); i++)
        {
            cout << "[ ";
            for (int j = 0; j < p[i].size(); j++)
            {
                cout << p[i][j] << " ";
            }
            cout << "]" << endl;
        }
    }
};




int main()
{
    BiTree BTO;
    Solution S;
    vector<int> a = { 3,9,20,null,null,15,7 };
    TreeNode* T = BTO.InitBiTree(a);
    //PrintBiTree(T);
    vector<vector<int>> p = S.levelOrder(T);
    S.PrintResult(p);

}

相对c语言来说，最大的不同点是关于二维向量的操作，首先根据测试得知，向量类型的数据不是指针，不能返回nullptr，然后他作为参数也不是值传递，应该是指针传递或者引用传递，总之就是可以直接对其进行修改，而且新建的向量不赋初始值的情况下是个空向量。
关于向量的操作以及队列的操作见
→→→C++标准库之vector（各函数及其使用全）
→→→C++标准库之队列（queue）

然后就是二维向量的操作，先要把一个一维向量添加到原二维向量中，然后再向二维向量的一维向量中添加元素。

❤ 2021.10.18 ❤
今天的题目是：

将有序数组转换为二叉搜索树

在这里插入图片描述

我的思路：
平衡二叉树，就是任何一个节点左右分支的节点数只差不超过1，再加上搜索树，就是任一个节点左边都比他小，右边都比他大，那么要实现平衡二叉搜索树首先得对输入数组进行排序，然后用二分的方法来取输入节点。
首先搭建测试环境框架。
不对，这个题的题解就是生成二叉树，所以不需要测试环境！只要个打印树的函数测试一下就行了！那就省事了
直接把完整程序贴上了

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode {
	int val;
	struct TreeNode* left;
	struct TreeNode* right;
};

typedef struct TreeNode BiTNode, * BiTree;

int cmp(const void* _a, const void* _b)
{
	return *(int*)_a - *(int*)_b;
}

struct TreeNode* CreatBiTree(int* nums, int start, int end)
{
	BiTNode* p = NULL;
	if (end - start > 0)
	{
		p = (BiTree)malloc(sizeof(BiTNode));
		p->val = nums[(end - start) / 2 + start];
		p->left = CreatBiTree(nums, start, (end - start) / 2 + start - 1);
		p->right = CreatBiTree(nums, (end - start) / 2 + start + 1, end);
	}
	else if (end - start == 0)
	{
		p = (BiTree)malloc(sizeof(BiTNode));
		p->val = nums[start];
		p->left = NULL;
		p->right = NULL;
	}
	return p;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
	if (numsSize == 0)
		return NULL;
	qsort(nums, numsSize, sizeof(int), cmp);
	return CreatBiTree(nums, 0, numsSize - 1);
}

void PrintBiTree(BiTree T)
{
	if (T)
	{
		printf("%d ", T->val);
		PrintBiTree(T->left);
		PrintBiTree(T->right);
	}
}

int main()
{
	int nums[] = { -10, -3, 0, 5, 9 };
	int n = 5;
	BiTree T = sortedArrayToBST(nums, n);
	PrintBiTree(T);
}

在这里插入图片描述
嗯。。。还可以
不过呢在和师妹讨论的时候我才发现他的题目里面说了给出的是有序数组，所以并不需要排序。。。
然后我看了答案

答案比我的代码要简介很多，主要是他把left==right和left <right的情况合并了，只对left>right的情况返回NULL，思考了一下确实是我没考虑全面，这两种情况应该是一种才对。

Mist_Orz

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
LeetCode刷题笔记（四）——初级算法——树

目录二叉树的最大深度终于到树了。。。❤ 2021.10.8 ❤今天的题目是：二叉树的最大深度我的思路：其实刚在数据结构课程里看到这个题的解法，但是呢，知道方法不一定自己能敲出来，特别是如何去构造一个二叉树我还没有实践过。...
复制链接

扫一扫

专栏目录