[学习报告]《LeetCode零基础指南》(第四讲) 指针

---

解题报告

重新排列数组

题目链接：1470. 重新排列数组

题目描述

给你一个数组 nums ，数组中有 2n 个元素，按 [x₁,x₂,…,x_n,y₁,y₂,…,y_n] 的格式排列。
请你将数组按 [x₁,y₁,x₂,y₂,…,x_n,y_n] 格式重新排列，返回重排后的数组。

解题思路

$(1)$ 提示返回的数组需要通过 malloc 分配内存，调用后会进行 free 清理操作。
$(2)$ 申请一个长度为 numsSize 的数组，首地址为 ret。
$(3)$ i 为奇数，填入关于 y 的数字。
$(4)$ i 为偶数，填入关于 x 的数字。
$(5)$ 返回数组的长度。
$(6)$ 返回申请的数组首地址。

/**
 * Note: The returned array must be malloced, assume caller calls free().//(1)
 */
int* shuffle(int* nums, int numsSize, int n, int* returnSize){
    int *ret = (int *)malloc(sizeof(int) * numsSize);                    //(2)
    for(int i = 0; i < numsSize; i ++ ){
        if(i & 1)														 //(3)
            ret[i] = nums[n + i / 2];
        else													         //(4)
            ret[i] = nums[i / 2];
    }
    *returnSize = numsSize;												 //(5)
    return ret;                                                          //(6)   
}

数组串联

题目链接：1929. 数组串联

题目描述

给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：
ans[i] == nums[i]
ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组 串联 形成。
返回数组 ans 。

解题思路

分配给 ans 数组的内存为 numsSize * 2。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* getConcatenation(int* nums, int numsSize, int* returnSize){
    int *ans = (int *)malloc(sizeof(int) * numsSize * 2);
    for(int i = 0; i < numsSize; i ++ ){
        ans[i] = ans[i + numsSize] = nums[i];
    }
    *returnSize = numsSize * 2;
    return ans;
}

基于排列构建数组

题目链接：1920. 基于排列构建数组

题目描述

给你一个 从 0 开始的排列 nums（下标也从 0 开始）。请你构建一个 同样长度 的数组 ans ，其中，对于每个 i（0 <= i < nums.length），都满足 ans[i] = nums[nums[i]] 。返回构建好的数组 ans 。
从 0 开始的排列 nums 是一个由 0 到 nums.length - 1（0 和 nums.length - 1 也包含在内）的不同整数组成的数组。

解题思路

按题意：ans[i] = nums[nums[i]];

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* buildArray(int* nums, int numsSize, int* returnSize){
    int *ans = (int *)malloc(sizeof(int) * numsSize);
    for(int i = 0; i < numsSize; i ++ ){
        ans[i] = nums[nums[i]];
    }
    *returnSize = numsSize;
    return ans;
}

一维数组的动态和

题目链接：1480. 一维数组的动态和

题目描述

给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。

解题思路

先手动给 sum[0] 赋值 nums[0]，避免出界。
for 循环从 1 开始 sum[i] = nums[i] + sum[i - 1] 求动态和。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* runningSum(int* nums, int numsSize, int* returnSize){
    int *sum = (int *)malloc(sizeof(int) * numsSize);
    sum[0] = nums[0];
    for(int i = 1; i < numsSize; i ++){
        sum[i] = nums[i] + sum[i - 1];
    }
    *returnSize = numsSize;
    return sum;
}

左旋转字符串

题目链接：剑指 Offer 58 - II. 左旋转字符串

题目描述

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"

解题思路

内存申请要多一个用来存放结尾标记 ‘\0’。
字符串首尾相接可以用取模来实现。
加上结尾标记 ‘\0’，字符串的长度就可以通过 strlen 获取。

char* reverseLeftWords(char* s, int n){
    int l = strlen(s);
    char *ans = (char *)malloc(sizeof(char) * (l + 1));
    for(int i = 0; i < l; i ++ ){
        ans[i] = s[(i + n) % l];
    }
    ans[l] = '\0';
    return ans;
}

IP 地址无效化

题目链接：1108. IP 地址无效化

题目描述

给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 “[.]” 代替了每个 “.”。

解题思路

遇到 ‘.’，就添加 ‘[’，’.’，’]’，否则添加原字符。
最后加上 ‘\0’，表示字符串的结尾。

char * defangIPaddr(char * address){
    char *ans = (char *)malloc(sizeof(char) * 1000);
    int l = 0;
    for(int i = 0; address[i]; i ++ ){
        if(address[i] == '.'){
            ans[l ++ ] = '[';
            ans[l ++ ] = '.';
            ans[l ++ ] = ']';
        }else
            ans[l ++ ] = address[i];
    }
    ans[l] = '\0';
    return ans;
}

替换空格

题目链接：剑指 Offer 05. 替换空格

题目描述

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

解题思路

与上题类似，注意：0 <= s 的长度 <= 10000，应分配内存需 > 30000。

char* replaceSpace(char* s){
    int l = 0;
    char *ans = (char *)malloc(sizeof(char) * 30010);
    for(int i = 0; s[i]; i ++ ){
        if(s[i] == ' '){
            ans[l ++ ] = '%%';
            ans[l ++ ] = '2';
            ans[l ++ ] = '0';
        }else
            ans[l ++ ] = s[i];
    }
    ans[l] = '\0';
    return ans;
}

有多少小于当前数字的数字

题目链接：1365. 有多少小于当前数字的数字

题目描述

给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。
换而言之，对于每个 nums[i] 你必须计算出有效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。
以数组形式返回答案。

解题思路

双重循环，枚举每个数字，将它与除自己外的每个数字比较即可。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize){
    int *ans = (int *)malloc(sizeof(int) * numsSize);
    for(int i = 0; i < numsSize; i ++ ){
        ans[i] = 0;
        for(int j = 0; j < numsSize; j ++ )
            if(i != j && nums[i] > nums[j])
                ans[i] ++;
    }
    *returnSize = numsSize;
    return ans;
}

打印从1到最大的n位数

题目链接：剑指 Offer 17. 打印从1到最大的n位数

题目描述

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

解题思路

n 位数字共有 10ⁿ - 1个数字，需要开辟 10ⁿ - 1 大小的空间。
注意从下标 0 开始存放的是 1，所以存入的数字为下标加 1。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* printNumbers(int n, int* returnSize){
    int f = 1;
    for(int i = 0; i < n; i ++ )
        f *= 10;
    f --;
    int *ans = (int *)malloc(sizeof(int) * f);
    for(int i = 0; i < f; i ++ )
        ans[i] = i + 1;
    *returnSize = f;
    return ans;
}

按既定顺序创建目标数组

题目链接：1389. 按既定顺序创建目标数组

题目描述

给你两个整数数组 nums 和 index。你需要按照以下规则创建目标数组：
目标数组 target 最初为空。
按从左到右的顺序依次读取 nums[i] 和 index[i]，在 target 数组中的下标 index[i] 处插入值 nums[i] 。
重复上一步，直到在 nums 和 index 中都没有要读取的元素。
请你返回目标数组。
题目保证数字插入位置总是存在。

解题思路

$(1)$ l 存放当前 target 数组的长度。
$(2)$ 如果 index[i] < l，说明需要对数组插入数字，将插入位置及之后的数字都向后移一位。
$(3)$ 将对应的数字赋值。
$(4)$ 数组长度加 1。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* createTargetArray(int* nums, int numsSize, int* index, int indexSize, int* returnSize){
    int *target = (int *)malloc(sizeof(int) * numsSize);
    int l = 0;													//(1)
    for(int i = 0; i < indexSize; i ++ ){
        for(int j = l; j > index[i]; j -- )						//(2)
            target[j] = target[j - 1];
        target[index[i]] = nums[i];								//(3)
        l ++ ;													//(4)
    }
    *returnSize = numsSize;
    return target;
}