day32_LC学习计划：数据结构基础

236.二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1：

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出：3
解释：节点 5 和节点 1 的最近公共祖先是节点 3 。
示例 2：

 

输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出：5
解释：节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。
示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1
 

提示：

树中节点数目在范围 [2, 105] 内。
-109 <= Node.val <= 109
所有 Node.val 互不相同 。
p != q
p 和 q 均存在于给定的二叉树中。

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

非递归后序遍历yyds。 

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

struct TreeNode** ancenstor(struct TreeNode* root, struct TreeNode* target, int* top){
    struct TreeNode** stack=malloc(sizeof(struct TreeNode*)*SIZE), *prev=NULL;
    while(root||(*top)>-1){
        while(root){
            stack[++(*top)]=root;
            root=root->left;
        }
        root=stack[*top];
        if(root==target) break;
        if(!root->right||root->right==prev){
            prev=root;
            root=NULL;
            (*top)--;     
        }else{
            root=root->right;
        }
    }
    return stack;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    int topP=-1,topQ=-1,max=0;
    struct TreeNode** stackP,*nodeP=root,**stackQ,*nodeQ=root;
    stackP=ancenstor(nodeP,p,&topP);
    stackQ=ancenstor(nodeQ,q,&topQ);
    for(int i=0;i<=topP&&i<=topQ;i++){
        if(stackP[i]==stackQ[i]){
            max=i>max?i:max;
        }
    }
    return stackP[max];
}

297.二叉树的序列化与反序列化

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

示例 1：

输入：root = [1,2,3,null,null,4,5]
输出：[1,2,3,null,null,4,5]
示例 2：

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

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

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

提示：

树中结点数在范围 [0, 104] 内
-1000 <= Node.val <= 1000

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

学习几个函数，sprintf(des,"%d",123)，可以把123保存为字符串保存在des数组中，atoi(char*)把字符串转变为整数。

#define MAX_SIZE 100000
#define STR_SIZE 10

void pre_order(struct TreeNode *root, char * data){
    if(root == NULL){
        strcat(data, "#");
        strcat(data, ",");
        return;
    }
    char tmp[STR_SIZE] = "";
    sprintf(tmp, "%d", root->val); // 技巧
    strcat(data, tmp);
    strcat(data, ",");
    pre_order(root->left, data);
    pre_order(root->right, data);
}

char* serialize(struct TreeNode* root) {
    char * ans = malloc(sizeof(char) * MAX_SIZE);
    memset(ans, '\0', sizeof(char) * MAX_SIZE);
    pre_order(root, ans);
    return ans;  
}


struct TreeNode * createTree(char *data, int *index){
    if(data[*index] == '#'){
        (*index)++; // ‘#’
        (*index)++; // ‘,’
        return NULL;
    }
    struct TreeNode * root = malloc(sizeof(struct TreeNode));
    char tmp[STR_SIZE] = "";
    int k = 0;
    while(data[*index] != ','){
        tmp[k++] = data[*index];
        (*index)++;
    }
    (*index)++; // 因为此时data[*index] = ','
    root->val = atoi(tmp); // 获取数值
    root->left = createTree(data, index); // 递归左子树
    root->right = createTree(data, index); // 递归右子树
    return root;
}
struct TreeNode* deserialize(char* data) {
    int index = 0; // index表示数组下标，不需要回溯
    return createTree(data, &index);  
}