day11_LC学习计划：数据结构入门

102.二叉树的层序遍历

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

示例 1：

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

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

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

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、idea：

树的基操。

二、解法：

 略

三、代码实现细节的学习：

1. 二维数组和elementType**在LC做题时不是一个东西。
2. elementType** variable当写成*variable时，可以看作是在操作左边第一个指针。

/**
 * 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){
    int **ret=malloc(sizeof(int *)*2000);
    *returnSize=0;
    *returnColumnSizes=malloc(sizeof(int)*2000);
    if(root==NULL){
        return NULL;
    }
    struct TreeNode *queue[2000];
    int front=0,rear=0;
    queue[rear++]=root;
    while(front<rear){
        int curLevel=rear,colSize=0;
        ret[*returnSize]=malloc(sizeof(int)*(rear-front));
        while(front<curLevel){
            struct TreeNode *tmp=queue[front++];
            ret[*returnSize][colSize++]=tmp->val;
            if(tmp->left!=NULL){
                queue[rear++]=tmp->left;
            }
            if(tmp->right!=NULL){
                queue[rear++]=tmp->right;
            }
        }
        (*returnColumnSizes)[*returnSize]=colSize;
        (*returnSize)++;
    }
    return ret;
}

104.二叉树的最大深度

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

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

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

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

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 

一、idea：

层序遍历

二、解法：

1. DFS
2. BFS

三、代码实现细节的学习：

1、DFS更加简便，处理树时很需要这样的递归思想。

/**
 * 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 fmax(maxDepth(root->left),maxDepth(root->right))+1;
    }
    return 0;
}

2、层序遍历/BFS

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


int maxDepth(struct TreeNode* root){
    int maxDepth=0, front=0, rear=0;
    struct TreeNode* queue[9000];
    queue[rear++]=root;
    while(root!=NULL&&front<rear){
        int curLevel=rear;
        while(front<curLevel){
            struct TreeNode *tmp=queue[front++];
            if(tmp->left!=NULL){
                queue[rear++]=tmp->left;
            }
            if(tmp->right!=NULL){
                queue[rear++]=tmp->right;
            }
        }
        maxDepth++;
    }
    return maxDepth;
}

一、idea：

分别递归查找左右子树，左子树用前序遍历，右子树用反向前序遍历，如果node不相等，说明不对称。

二、解法：

1. 递归
2. 迭代

三、代码实现细节的学习：

1、学习一下。

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


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

int check(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&&check(p->right,q->left)&&check(p->left,q->right);
}

2、迭代，递归的替代品也不总是栈，看具体的需求而定，这道题所需要的是，加入的两个node同时遍历，所以使用队列更好。内存溢出的时候也注意看一下变量是否正确。

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


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

int check(struct TreeNode *p,struct TreeNode *q){
    struct TreeNode **queue=(struct TreeNode**)malloc(sizeof(struct TreeNode*)*10000);
    int front=0,rear=0;
    queue[rear++]=p;
    queue[rear++]=q;
    while(front<rear){
        struct TreeNode *tmp1=queue[front++];
        struct TreeNode *tmp2=queue[front++];
        if(tmp1==NULL&&tmp2==NULL){
            continue;
        }
        if((tmp1==NULL||tmp2==NULL)||(tmp1->val!=tmp2->val)){
            return false;
        }
        queue[rear++]=tmp1->left;
        queue[rear++]=tmp2->right;
        
        queue[rear++]=tmp1->right;
        queue[rear++]=tmp2->left;
    }
    return true;
}