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

199.二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
示例 2:

输入: [1,null,3]
输出: [1,3]
示例 3:

输入: []
输出: []
 

提示:

二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100 

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

BFS，层序输出最后一个节点的值，有点easy。 

/**
 * 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().
 */
#define MAXSIZE 2000

int* rightSideView(struct TreeNode* root, int* returnSize){
    *returnSize=0;
    if(!root) return NULL;
    struct TreeNode* nodeQueue[MAXSIZE];
    int* ret=malloc(sizeof(int)*MAXSIZE),front=0,rear=0;
    nodeQueue[rear++]=root;
    while(front<rear){
        int levelEnd=rear;
        struct TreeNode* data=nodeQueue[levelEnd-1];
        ret[(*returnSize)++]=data->val;
        while(front<levelEnd){
            struct TreeNode* tmp=nodeQueue[front++];
            if(tmp->left){
                nodeQueue[rear++]=tmp->left;
            }
            if(tmp->right){
                nodeQueue[rear++]=tmp->right;
            }
        }
    }
    return ret;
}

学习一下 DFS写法。从节点的右节点开始遍历，用D和max_depth维护最右视图，即如果在某一层内已经保存了当前层的节点，就不用再存了，说明现在保存的已经是最右视图了。max_depth需要用指针保证在每个递归中的max_depth是一样的。

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

// function declaration
void dfs(TreeNode*, int, int*, int*, int*);

int* rightSideView(TreeNode* root, int* returnSize) {
  int* ans = malloc(sizeof(int) * 1e4);
  *returnSize = 0;
  int max_depth = -1;
  dfs(root, 0, &max_depth, ans, returnSize);
  return ans;
}

void dfs(TreeNode* root, int d, int* max_depth, int* ans, int* returnSize) {
  if (!root) return;
  if (d > *max_depth) {
    *(ans + (*returnSize)++) = root->val;
    *max_depth = d;
  }
  dfs(root->right, d + 1, max_depth, ans, returnSize);
  dfs(root->left,  d + 1, max_depth, ans, returnSize);
}

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]
示例 2：

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

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

提示：

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

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

利用后序遍历的特性。 

/**
 * 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().
 */
#define MAXSIZE 20000

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes){
    *returnSize=0;
    if(!root) return NULL;
    int** ret=malloc(sizeof(int*)*MAXSIZE),top=-1;
    *returnColumnSizes=malloc(sizeof(int)*MAXSIZE);
    struct TreeNode* stack[MAXSIZE],*node=root,*prev=NULL;
    while(node||top>-1){
        while(node){
            stack[++top]=node;
            node=node->left;
        }
        node=stack[top];
        if(node->right==NULL||node->right==prev){
            if(node->left==NULL&&node->right==NULL){
                int sum=0;
                int* tmp=malloc(sizeof(int)*(top+1));
                struct TreeNode* tmpNode=NULL;
                for(int i=0;i<=top;i++){
                    tmpNode=stack[i];
                    sum+=tmpNode->val;
                    tmp[i]=tmpNode->val;
                }
                if(sum==targetSum){
                    ret[(*returnSize)]=tmp;
                    (*returnColumnSizes)[*returnSize]=top+1;
                    (*returnSize)++;
                }
            }
            top--;
            prev=node;
            node=NULL;
        }else{
            node=node->right;
        }
    }
    return ret;
}

DFS。写路经总和的时候DFS好像还是很方便的，写二需要返回整个路径好像有点太复杂= =

/**
 * 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().
 */
#define SIZE 2001

int** ret;
int retSize;
int* retColSize;

int* path;
int pathSize;


void dfs(struct TreeNode* root,int targetSum){
    if(!root) return;
    path[pathSize++]=root->val;
    targetSum-=root->val;
    if(!root->left&&!root->right&&targetSum==0){
        int* tmp=malloc(sizeof(int)*pathSize);
        memcpy(tmp,path,sizeof(int)*pathSize);
        ret[retSize]=tmp;
        retColSize[retSize++]=pathSize;
    }
    dfs(root->left,targetSum);
    dfs(root->right,targetSum);
    pathSize--;//说明子节点都访问完了，应该减去子节点的pathSize，还要给其他的path用
}

int** pathSum(struct TreeNode* root, int targetSum, int* returnSize, int** returnColumnSizes){
    ret=malloc(sizeof(int*)*SIZE);
    retColSize=malloc(sizeof(int)*SIZE);
    retSize=pathSize=0;
    path=malloc(sizeof(int)*SIZE);
    dfs(root,targetSum);
    *returnSize=retSize;
    *returnColumnSizes=retColSize;
    return ret;
}

450.删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

首先找到需要删除的节点；
如果找到了，删除它。
 

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3
输出：[5,4,6,2,null,null,7]
解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。
一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。
另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0
输出: [5,3,6,2,4,null,7]
解释: 二叉树不包含值为 0 的节点
示例 3:

输入: root = [], key = 0
输出: []
 

提示:

节点数的范围 [0, 104].
-105 <= Node.val <= 105
节点值唯一
root 是合法的二叉搜索树
-105 <= key <= 105
 

进阶： 要求算法时间复杂度为 O(h)，h 为树的高度。

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

这题完全是帮助熟悉BST的性质。

中序遍历下的BST是升序排列。

可以知道中序BST的前驱是左子树的最右节点。

后继是右子树的最左节点。 

删完当前值记得要递归删下去。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int predecessor(struct TreeNode* root){
    root=root->left;
    while(root->right) root=root->right;
    return root->val;
}

int successor(struct TreeNode* root){
    root=root->right;
    while(root->left) root=root->left;
    return root->val;
}

struct TreeNode* deleteNode(struct TreeNode* root, int key){
    if(!root) return NULL;

    if(key>root->val) root->right=deleteNode(root->right,key);
    else if(key<root->val) root->left=deleteNode(root->left,key);
    else{
        if(!root->left&&!root->right){
            root=NULL;
        }else if(root->right){
            root->val=successor(root);
            root->right=deleteNode(root->right,root->val);
        }else{
            root->val=predecessor(root);
            root->left=deleteNode(root->left,root->val);
        }
    }
    return root;
}