文章目录
一、求二叉树的节点个数
第一种思路是加一个计数器，为了保证每次计数器的值在经过一个非空结点后都能++，我们传一个整型变量的指针。
void BinaryTreeSize(BTNode* root, int* count)
{
assert(count);
if (root == NULL)
return;
(*count)++;
BinaryTreeSize(root->left, count);
BinaryTreeSize(root->right, count);
}
第二种思路是分治的思想，求二叉树的结点个数等价于求它的左子树的结点个数加上求它右子树的结点个数再加1，注意处理一下空树的情况，空树没有节点，返回0.
int BinaryTreesize(BTNode* root)
{
return (root == NULL) ? 0 :
(1 + BinaryTreesize(root->left)
+ BinaryTreesize(root->right));
}
二、二叉树的前序 中序 后序遍历OJ
题目描述
思路
本题痛点在于要用一个数组来存放二叉树的前序遍历序列，如果用C语言写，我们需要malloc出来一块空间，但是我们又不知道空间又多大，怎么办呢？可以用前面提到的求二叉树结点个数的函数得到二叉树的节点个数，这就是我们要开辟的数组大小。
本题的另一个痛点在于我们在写入数组的时候需要传一个下标来控制这次填入的结点值在哪个位置，用全局变量也可以做到这件事，但是会破坏程序的可读性，因此我们考虑一个整形变量的指针，每次填入后解引用这个指针访问到那个整形变量然后++之。
代码
int BinaryTreeSize(struct TreeNode* root)
{
return root == 0 ? 0 : 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void _preorderTraversal(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
a[(*pi)++] = root->val;
_preorderTraversal(root->left, a, pi);
_preorderTraversal(root->right, a, pi);
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
int size = BinaryTreeSize(root);
int* a = (int*)malloc(sizeof(int)*size);
int i = 0;
_preorderTraversal(root, a, &i);
*returnSize = size;
return a;
}
中序遍历，后序遍历也是类似。
int BinaryTreeSize(struct TreeNode* root)
{
return root == NULL ? 0 : 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void _inorderTraversal(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
_inorderTraversal(root->left, a, pi);
a[(*pi)++] = root->val;
_inorderTraversal(root->right, a, pi);
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
if(root == NULL)
{
*returnSize = 0;
return NULL;
}
int size = BinaryTreeSize(root);
int* a = (int*)malloc(sizeof(int)*size);
int i = 0;
_inorderTraversal(root, a, &i);
*returnSize = size;
return a;
}
int BinaryTreeSize(struct TreeNode* root)
{
return root == NULL ? 0 :
1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}
void _postorderTraversal(struct TreeNode* root, int* a, int* pi)
{
if (root == NULL)
{
return;
}
_postorderTraversal(root->left, a, pi);
_postorderTraversal(root->right, a, pi);
a[(*pi)++] = root->val;
}
int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
if (root == NULL)
{
*returnSize = 0;
return NULL;
}
int size = BinaryTreeSize(root);
int* a = (int*)malloc(sizeof(int)*size);
*returnSize = size;
int i = 0;
_postorderTraversal(root, a, &i);
return a;
}
用C写真的很麻烦，我们可以用C++中的vector容器轻易的完成这件事。vector容器是一个动态数组，root->val写入数组就push_back(root->val)，数组的大小它会自动帮我们扩容，最后返回我们创建的vector容器就行。
思路就是创建一个子函数用于递归，向这个子函数传vector<int>的引用（因为这样就可以修改我们创建的vector<int> vec的值），然后其余思路和C中类似。
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> vec;
_preorderTraversal(root, vec);
return vec;
}
private:
void _preorderTraversal(TreeNode* root, vector<int> &vec)
{
if (root == nullptr)
{
return;
}
vec.push_back(root->val);
_preorderTraversal(root->left, vec);
_preorderTraversal(root->right, vec);
}
};
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root)
{
vector<int> vec;
_inorderTraversal(root, vec);
return vec;
}
private:
void _inorderTraversal(TreeNode* root, vector<int> &vec)
{
if (root == nullptr)
{
return;
}
_inorderTraversal(root->left, vec);
vec.push_back(root->val);
_inorderTraversal(root->right, vec);
}
};
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root)
{
vector<int> vec;
_postorderTraversal(root, vec);
return vec;
}
private:
void _postorderTraversal(TreeNode* root, vector<int> &vec)
{
if (root == nullptr)
{
return;
}
_postorderTraversal(root->left, vec);
_postorderTraversal(root->right, vec);
vec.push_back(root->val);
}
};
三、二叉树叶子结点的个数
仿照上面的分治思想，求一个二叉树叶子结点的个数，不就等价于求它左子树叶子结点的个数加上求他右子树叶子结点的个数吗？
这里要注意处理两种情况，什么样的结点是叶子结点呢？显然左右子树都为空的结点是叶子结点，他们要return 1；还可能出现什么样的意外呢，就是一个结点它只有左子树没有右子树，进去右子树是个空树，这种情况直接返回0就好了，空树没有叶子结点。
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
//不能root->left == root->right == NULL
//这样是前两个的比较结果和最后一个比
if (root->left ==NULL && root->right == NULL)
return 1;
return BinaryTreeLeafSize(root->left) +
BinaryTreeLeafSize(root->right);
}
四、二叉树第K层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
同样一个分治思想，求当前树第k层的节点个数等价于它左子树第k-1层的结点个数和右子树第k-1层结点个数中的较大者。
注意控制返回条件，如果是空树，那不管你的k是多少我都返回0，如果是非空的树并且k=1的时候，这时候我们能处理了，因为这个意思就是要求当前树第1层的结点个数，显然返回1就行了。
int BinaryTreeLevelKSize(BTNode* root, int k)
{
//其实唯一能明确给出返回值的就是两种情况
//一种是到空了 不管k是多少 返回0
//另一种是求某个树的第一层 返回值显然是1
assert(k >= 1);
//如果root是空 对应是空树的情况了 也就不存在第k层的结点个数了
//直接返回0就行了
if (root == NULL)
return 0;
if (k == 1)
return 1;
//走到这里root不等于空 k也不等于1
//转化为求左子树和右子树的k-1层的节点个数
return BinaryTreeLevelKSize(root->left, k - 1)
+ BinaryTreeLevelKSize(root->right, k - 1);
}
五、二叉树的最大深度
题目描述
思路
求一个二叉树的最大深度等价于其左子树深度和右子树深度中的较大者+1。
注意控制条件，我们只知道空树的深度是0。
代码
int maxDepth(struct TreeNode* root)
{
//如果是空树 深度为0
if (root == NULL)
{
return 0;
}
//求树的深度等于左树的深度和右树的深度的较大者+1
int leftDepth = maxDepth(root->left);
int rightDepth = maxDepth(root->right);
return leftDepth > rightDepth ?
leftDepth + 1 : rightDepth + 1;
}
六、二叉树的查找
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
考虑类似前序遍历的方法来查找，如果查到了空树，就返回NULL，如果查找到的结点的值等于x，就返回这个结点的地址，这里要注意控制，如果在左子树找到了，那就会返回一个非空值，这种情况就不要再查了，直接返回这个找到的结点的地址，同理右子树，如果左右子树都没找到，最后返回NULL。
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->data == x)
return root;
BTNode* ret1 = BinaryTreeFind(root->left, x);
if (ret1 != NULL)//如果找到了就别往下走了 直接返回
return ret1;
BTNode* ret2 = BinaryTreeFind(root->right, x);
if (ret2 != NULL)//同上
return ret2;
return NULL;//走到这里说明左边右边都没找到
}
七、单值二叉树
题目描述
思路
首先，空树一定是单值的，空树则返回NULL；然后我们要重点抓住能够确定返回值的情况，如果这个结点的左子树非空但左子树根节点的值不等于右子树根结点的值，则返回false，同理右子树。如果上面两关都过了，就去检查他的左子树和它的右子树。
代码
bool isUnivalTree(struct TreeNode* root)
{
//空树当然是单值的
if (root == NULL)
{
return true;
}
//抓住能确定返回值的 相同确定不了返回值只能进入下一层
//如果左子树非空且左子树根结点的值与当前结点不相同 则返回false
if (root->left && root->left->val != root->val)
{
return false;
}
//如果右子树非空且右子树根结点的值与当前结点不相同 则返回false
if (root->right && root->right->val != root->val)
{
return false;
}
return isUnivalTree(root->left) &&
isUnivalTree(root->right);
}
八、翻转二叉树
题目描述
思路
翻转一个二叉树等价于交换它的左右子树，然后去翻转它的左子树和它的右子树。
代码
void swap(struct TreeNode** pleft, struct TreeNode** pright)
{
struct TreeNode* tmp = *pleft;
*pleft = *pright;
*pright = tmp;
}
void _invertTree(struct TreeNode* root)
{
if (root == NULL)
{
return;
}
//反转二叉树可以分解为交换这棵树的左子树和右子树
//然后去反转它的左子树和右子树
swap(&root->left, &root->right);
_invertTree(root->left);
_invertTree(root->right);
}
struct TreeNode* invertTree(struct TreeNode* root)
{
if (root == NULL)
{
return NULL;
}
_invertTree(root);
return root;
}
九、相同的树
题目描述
思路
如果两个都是空树，那么这两棵树相同，返回true，如果一棵树为空，另一棵树非空，返回false，如果两棵树都非空且两棵树的值不同，返回false，如果上面这些关都过了，那么去检查一下这两棵树的左子树是否相同和这两棵树的右子树是否相同。
代码
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if ( (p == NULL && q != NULL) || (p != NULL && q == NULL) )
{
return false;
}
if (p == NULL && q == NULL)
{
return true;
}
if (p->val != q->val)
{
return false;
}
return isSameTree(p->left, q->left)
&& isSameTree(p->right, q->right);
}
十、对称二叉树
题目描述
思路
;对称可以考虑用两个指针，你往左走我就往右走。
我们可以这样，用两个指针从根节点开始检查，先检查这两个树的空情况，如果都为空返回true，如果其中一棵树为空另一个不为空则返回false，然后检查这两个结点的值，如果结点的值不相等就返回false，如果这些关都过了就让第一个指针指向当前结点的左子树，另一个指针指向当前结点的右子树，进行检查；再让第一个指针指向当前结点的右子树，另一个指针指向当前结点的左子树，进行检查。
代码
bool check(struct TreeNode* root1, struct TreeNode* root2)
{
if (root1 == NULL && root2 == NULL)
{
return true;
}
if (root1 == NULL && root2 != NULL)
{
return false;
}
if (root1 != NULL && root2 == NULL)
{
return false;
}
if (root1->val != root2->val)
{
return false;
}
return check(root1->left, root2->right)
&& check(root1->right, root2->left);
}
bool isSymmetric(struct TreeNode* root)
{
if (root == NULL)
{
return true;
}
return check(root, root);
}
十一、判断一棵树是否是另一颗树的子树
题目描述
思路
我们可以用中序遍历的思路遍历root的每一棵子树，然后用判断树是否相等的函数判断subRoot是否和root的这个子树相等，如果相等，就返回true；如果不相等，则继续遍历当前树的左子树和右子树，左子树和右子树中有一棵树他的子树和subRoot相等，那么就返回true，所以这里可以用或运算符。
代码
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if (p == NULL && q == NULL)
{
return true;
}
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);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
//检查每棵root的每棵子树和subRoot是否相等。
if (root == NULL)
{
return false;
}
if (isSameTree(root, subRoot) == true)
{
return true;
}
//不相等就看看左子树和右子树里头有没有和subRoot相等的树
return isSubtree(root->left, subRoot)
|| isSubtree(root->right, subRoot);
}
十二、二叉树的层序遍历
层序遍历是一种广度优先遍历，需要一个队列来辅助实现。首先如果根结点非空，让根结点入队列，然后pop出来根结点，并且打印它的值，然后判断它的左右子树是否为空，不为空则让左右子树入队列，一直循环到队列为空为止。
void LevelOrder(BTNode* root)
{
if (root == NULL)
return;
Queue queue;
QueueInit(&queue);
QueuePush(&queue, root);
while (!QueueEmpty(&queue))
{
BTNode* tmp = Queuefront(&queue);
QueuePop(&queue);
printf("%c ", tmp->data);
if (tmp->left)
QueuePush(&queue, tmp->left);
if (tmp->right)
QueuePush(&queue, tmp->right);
}
//用队列一定记得销毁
Queuedestroy(&queue);
}
十三、判断二叉树是否为完全二叉树
完全二叉树的特性是如果把NULL也入队列，那么它的层序遍历序列非空结点一定会连续出现，出现第一个空结点以后，空结点也一定是连续出现的，而非完全二叉树必然会出现空结点后面有一个非空结点的情况。
bool BinaryTreecomplete(BTNode* root)
{
if (root == NULL)
return true;
Queue q;
QueueInit(&q);
QueuePush(&q, root);
while (!QueueEmpty(&q))
{
BTNode* tmp = Queuefront(&q);
QueuePop(&q);
//遇到空了就先出去去判断
if (tmp == NULL)
break;
else
{
QueuePush(&q, tmp->left);
QueuePush(&q, tmp->right);
}
}
while (!QueueEmpty(&q))
{
BTNode* front = Queuefront(&q);
//如果遇到空后后面还有非空结点
//
if (front)
{
Queuedestroy(&q);
return false;
}
QueuePop(&q);
}
Queuedestroy(&q);
return true;
}
十四、销毁二叉树
考虑到二叉树的结点存着他两个孩子的地址，直接free会丢失信息，应该先销毁它的左子树，再销毁它的右子树，再free根节点。一种后序遍历的思路。
void BinaryTreeDestroy(BTNode* root)
{
//考虑到当前结点存储了它的左右子树的信息
//我们可以采用后续的顺序销毁二叉树
if (root == NULL)
return;
BinaryTreeDestroy(root->left);
BinaryTreeDestroy(root->right);
free(root);
}
十五、用拓展前序二叉树序列建立二叉树
我的这篇文章中讨论了它的一种实现算法：没有返回值的递归算法
我们用带返回值的函数来实现这个算法，首先如果遇到’#'就让迭代器++走到字符串的下一个结点，然后返回NULL；否则创建一个新结点，他的值是当前迭代器指的字符，然后用一个先序遍历的思想创建他的左子树，创建他的右子树，最后，返回这个创建好的节点。
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
if (!newnode)
{
printf("malloc fail\n");
exit(-1);
}
newnode->data = a[(*pi)++];
newnode->left = BinaryTreeCreate(a, pi);
newnode->right = BinaryTreeCreate(a, pi);
return newnode;
}
360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
