day2-替换空格、重建二叉树、矩阵路径

面试题05. 替换空格

难度简单20

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

限制：

0 <= s 的长度 <= 10000

char* replaceSpace(char* s){
     
    char *p=(char*)malloc(3*(strlen(s)+1)*sizeof(char));
    char *ts=s,*tp=p;
    while(*ts!='\0')
    {
     
        if(*ts!=' ')
            *tp++=*ts++;
        else
        {
     
            *tp++='%';
            *tp++='2';
            *tp++='0';
            ts++;
        }
    }
    *tp='\0';
    return p;
}

需要注意的是：

1、空格是一个字符，%20是三个字符，不能一次性替换

2、用动态分配储存空间，不能直接char p[3*（strlen(s)+1）]；并且malloc里面不能用3 *strlen(s),字符串全为空格时将会报错。

3、p字符串的末尾必须加’\0’;

面试题07. 重建二叉树

难度中等104

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

返回如下的二叉树：

    3
   / \
  9  20
    /  \
   15   7

限制：

0 <= 节点个数 <= 5000

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){
     
	//递归结束条件，当其子树为空时
    if(preorderSize<=0)
        return NULL;
    struct TreeNode *root=(struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val=preorder[0];//前序遍历的第一个数为根结点
    int cnt=0;//记录左子树的结点个数
    
    //后序遍历中preorder[0]之前的结点值在左子树，之后的在右子树
    while(cnt<inorderSize&&inorder[cnt]!=preorder[0])
        cnt++;
    //递归创建左右子树，注意preorder、inorder首地址及其size.
    root->left=buildTree(preorder+1,cnt,inorder,cnt);
    root->right=buildTree(preorder+1+cnt,preorderSize-1-cnt,inorder+1+cnt,inorderSize-1-cnt);
    return root;//返回根结点
}

注意、思路

注意不要漏掉递归结束条件和返回root

思路：根据中序遍历和前序遍历可唯一确定二叉树，根据其特点确定根节点、左右子树、递归构造二叉树

面试题12. 矩阵中的路径

难度中等81

请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

[[“a”,“b”,“c”,“e”],
[“s”,“f”,“c”,“s”],
[“a”,“d”,“e”,“e”]]

但矩阵中不包含字符串“abfb”的路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入这个格子。

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

提示：

• 1 <= board.length <= 200
• 1 <= board[i].length <= 200

bool dfs(char **board,int boardSize,int *boardColSize,char *word,int i,int j,int k){
     
    int tx[4]={
     0,0,1,-1};//控制横坐标
    int ty[4]={
     1,-1,0,0};
    if(i<0||j<0||i>=boardSize||j>=boardColSize[i]||word[k]!=board[i][j])
        return false;
    //递归结束条件，遍历完word里面所有字符
    if(word[k+1]=='\0')
        return true;
    char t=board[i][j];
    board[i][j]='#';//置访问标记
    
    //通过坐标判断点board[i][j]处上下左右四个方向能否满足条件
    for(int m=0;m<4;m++)
    {
     
        int x=i+tx[m];//不要写成 i+=tx[m];
        int y=j+ty[m];
        if(dfs(board,boardSize,boardColSize,word,x,y,k+1))
            return true;
    }
    //回溯
    board[i][j]=t;
    return false;
}



bool exist(char** board, int boardSize, int* boardColSize, char* word){
     
    //遍历图是为了从任意点出发
    for(int i=0;i<boardSize;i++)
    {
     
        for(int j=0;j<boardColSize[i];j++)
        {
     
            //判断从任意点出发的路径
            if(dfs(board,boardSize,boardColSize,word,i,j,0))
                return true;
        }
    }
    return false;
}

思路、注意

思路：遍历图，从任意点出发，深度优先搜索，递归结束条件为

word[k+1]==’\0’;也就是说遍历完word所有字符。

注意 int x=i+tx[m];//不要写成 i+=tx[m];
int y=j+ty[m];