Binary Tree Classic OJ
Preorder traversal of binary tree
Link: https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int size(struct TreeNode* t)
{
if(t == NULL)
return 0;
else
return size(t->left) + size(t->right) + 1;
}
void _preorderTraversal(struct TreeNode* root, int* preorder_array, int* i)
{
if(root != NULL)
{
preorder_array[*i] = root->val;
(*i)++;
_preorderTraversal(root->left, preorder_array,i);
_preorderTraversal(root->right, preorder_array,i);
}
}
int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
int n = size(root);
int* preorder_array = (int*)malloc(sizeof(int) * n);
*returnSize = n;
int index = 0;
_preorderTraversal(root, preorder_array,&index);
return preorder_array;
}
Binary tree in-order traversal
Link: https://leetcode-cn.com/problems/binary-tree-inorder-traversal/submissions/ .
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int size(struct TreeNode *t)
{
if(t == NULL)
return 0;
else
return size(t->left) + size(t->right) + 1;
}
void _InorderTraversal(struct TreeNode *root, int *Inorder_array, int *i)
{
if(root != NULL)
{
_InorderTraversal(root->left, Inorder_array, i);
Inorder_array[*i] = root->val;
(*i)++;
_InorderTraversal(root->right, Inorder_array, i);
}
}
int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
int n = size(root);
int *Inorder_array = (int*)malloc(sizeof(int) * n);
*returnSize = n;
int index = 0;
_InorderTraversal(root, Inorder_array, &index);
return Inorder_array;
}
Post-order traversal of binary tree
Link: https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
Same as the pre-order and middle-order, here also uses the recursive algorithm,
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int size(struct TreeNode *t)
{
if(t == NULL)
return 0;
else
return size(t->left) + size(t->right) + 1;
}
void _postorderTraversal(struct TreeNode *root, int *postorder_array, int *i)
{
if(root != NULL)
{
_postorderTraversal(root->left, postorder_array, i);
_postorderTraversal(root->right, postorder_array, i);
postorder_array[*i] = root->val;
(*i)++;
}
}
int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
int n = size(root);
int *postorder_array = (int*)malloc(sizeof(int) * n);
*returnSize = n;
int index = 0;
_postorderTraversal(root, postorder_array, &index);
return postorder_array;
}
Are the binary trees equal
Link: https://leetcode-cn.com/problems/same-tree/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if(p == NULL && q == NULL)
return true;
if(p == NULL || q == NULL)
return false;
return p->val == q->val && isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}
Subtree of another tree
Link: https://leetcode-cn.com/problems/subtree-of-another-tree/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
if (p == NULL && q == NULL)
return true;
if (p == NULL || q == NULL)
return false;
return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
bool isSubtree(struct TreeNode* s, struct TreeNode* t)
{
if(t == NULL)
return true;
if(s == NULL)
return false;
if(isSameTree(s,t))
return true;
return isSubtree(s->left,t) || isSubtree(s->right,t);
}
Maximum depth of binary tree
Link: https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode* root)
{
if(root == NULL)
return 0;
int left_h = maxDepth(root->left);
int right_h = maxDepth(root->right);
return (left_h > right_h ? left_h : right_h) + 1;
}
Balanced binary tree
Link: https://leetcode-cn.com/problems/balanced-binary-tree/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode* root)
{
if(root == NULL)
return 0;
int left_h = maxDepth(root->left);
int right_h = maxDepth(root->right);
return (left_h>right_h ? left_h : right_h) + 1;
}
bool isBalanced(struct TreeNode* root)
{
if(root == NULL)
return true;
int left_h = maxDepth(root->left);
int right_h = maxDepth(root->right);
return abs(left_h - right_h) < 2 && isBalanced(root->left) && isBalanced(root->right);
}
Symmetric Binary Tree
Link: https://leetcode-cn.com/problems/symmetric-tree/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool _isSymmetric(struct TreeNode* t1,struct TreeNode* t2)
{
if(t1 == NULL && t2 == NULL)
return true;
if(t1 == NULL || t2 == NULL)
return false;
return t1->val == t2->val && _isSymmetric(t1->left, t2->right) && _isSymmetric(t1->right, t2->left);
}
bool isSymmetric(struct TreeNode* root)
{
if(root == NULL)
return true;
return _isSymmetric(root->left, root->right);
}
Binary tree creation and traversal
#include<stdio.h>
#include<assert.h>
typedef struct BinTreeNode
{
char data;
struct BinTreeNode* left;
struct BinTreeNode* right;
}BinTreeNode;
typedef BinTreeNode* BinTree;
BinTree CreatBinTree(const char *str, int* i)
{
if(str[*i] == '#' || str[*i] == '\0')
return NULL;
BinTreeNode* t = (BinTreeNode*)malloc(sizeof(BinTreeNode));
assert(t != NULL);
t->data = str[*i];
(*i)++;
t->left = CreatBinTree(str,i);
(*i)++;
t->right =CreatBinTree(str,i);
return t;
}
void InOrder(BinTree t)
{
if(t != NULL)
{
InOrder(t->left);
printf("%c ", t->data);
InOrder(t->right);
}
}
void DestroyBinTree(BinTree* t)
{
if(*t != NULL)
{
DestroyBinTree(&((*t)->left));
DestroyBinTree(&((*t)->right));
free(*t);
*t = NULL;
}
}
int main()
{
BinTree bt = NULL;
char arr[100] = {
0};
while(scanf("%s", arr) != EOF)
{
int index = 0;
bt = CreatBinTree(arr, &index);
InOrder(bt);
printf("\n");
DestroyBinTree(&bt);
}
return 0;
}