初级算法-树

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

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

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

示例：
给定二叉树 [3,9,20,null,null,15,7]，

返回它的最大深度 3 。

/**
 * 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;
    //如果我们知道了左子树和右子树的最大深度 l和 r，那么该二叉树的最大深度即为max(l,r)+1
    return fmax(maxDepth(root->left), maxDepth(root->right)) + 1;
}

二、验证二叉搜索树
给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

输入：root = [2,1,3]
输出：true

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool isBSTUtil(struct TreeNode* node, long long min, long long max)  
{  
  /* 是一颗空树 */
  if (node==NULL)  
     return true; 
        
  /* 结点的值小于等于最小值，或者大于等于最大值都是不合理的，返回false */  
  if (node->val <= min || node->val >= max)  
     return false;  
  
  /*否则递归地判断结点的左子树和右子树*/
  return 
    isBSTUtil(node->left, min, node->val) && 
    isBSTUtil(node->right, node->val, max); 
}  

bool isValidBST(struct TreeNode* root){
    return isBSTUtil(root,LONG_MIN, LONG_MAX);
}

三、对称二叉树
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

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

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

四、二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

/**
 * 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().
 */
 struct Queue
{
    struct TreeNode* node;
    struct Queue*    next;
};

void enQueue(struct Queue *queueHead, struct  TreeNode* node)
{
    //插入到尾部
    struct Queue* queueIt  = queueHead;
    while(queueIt->next != NULL)
    {
        queueIt = queueIt->next;
    }
    struct Queue *queueNew = malloc(sizeof(struct Queue));
    queueNew->node  = node;
    queueNew->next  = NULL;
    queueIt->next  = queueNew;
}

struct  TreeNode* deQueue(struct Queue *queueHead)
{
    //插入到尾部
    struct Queue* queueIt    = queueHead->next;
    struct  TreeNode* node;
    if(queueIt != NULL)
    {
        queueHead->next =  queueIt->next;
        node = queueIt->node;
        free(queueIt);                      //释放空间
        return node;
    }
    return NULL;
}

void  freeQueue(struct Queue *queueHead)
{
    //清理链表
    struct Queue*  queueIt    = queueHead->next;
    struct Queue*  queuePre  = queueHead->next;
    if(queueIt != NULL)
    {
        queuePre = queueIt;
        queueIt  =  queueIt->next;
        free(queuePre);                      //释放空间
    }
    free(queueHead);

}



void bfs(int* returnSize,int** returnColumnSizes,int **returnNum,struct Queue* queueHead)
{
    struct Queue* queueIt = queueHead->next;
    if (queueIt->node == NULL)
    {
        return;
    }
    int count = 0;
    returnNum[*returnSize] = (int*)malloc(sizeof(int) * 2000);
    while(1)
    {
       struct TreeNode * node = deQueue(queueHead);
       if(node == NULL)
       {
           break;
       }
       returnNum[*returnSize][count] = node->val;
       count++;

       if(node->left != NULL)
       {
           enQueue(queueHead,node->left);
       }

       if(node->right != NULL)
       {
           enQueue(queueHead,node->right);
       }
    }
    enQueue(queueHead,NULL);
    (*returnColumnSizes)[*returnSize ] = count;
    *returnSize = *returnSize + 1;
    bfs(returnSize,returnColumnSizes,returnNum,queueHead);
}


int** levelOrder(struct TreeNode* root,int* returnSize,int** returnColumnSizes)
{
    *returnSize = 0;
    if(root == NULL)
        return NULL;
    int** returnNum = (int**)malloc(sizeof(int*) * 2000);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 2000);
    struct Queue *queueHead = malloc(sizeof(struct Queue));
    queueHead->next = NULL;
    queueHead->node = NULL;
    enQueue(queueHead,root);
    enQueue(queueHead,NULL);
    bfs(returnSize,returnColumnSizes,returnNum,queueHead);
    freeQueue(queueHead);
    return returnNum;
}

五、将有序数组转换为二叉搜索树
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。

高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]
解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

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

struct TreeNode* helper(int* nums, int left, int right) {
    if (left > right) {
        return NULL;
    }

    // 总是选择中间位置左边的数字作为根节点
    int mid = (left + right) / 2;

    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = nums[mid];
    root->left = helper(nums, left, mid - 1);
    root->right = helper(nums, mid + 1, right);
    return root;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
    return helper(nums, 0, numsSize - 1);