算法学习——引导（指针）

第一题 数组串联

class Solution {
public:
    vector<int> getConcatenation(vector<int>& nums) {
        //空间复杂度O（n）
        // int n = nums.size();
        // vector<int> ans(2 * n);
        // for(int i = 0; i < 2 * n; i++)
        // {
        //     ans[i] = nums[i % n];
        // }
        // return ans;
    
        //空间复杂度O（1）；
        int n = nums.size();
        for(int i = 0; i < n; i++)
        {
            nums.push_back(nums[i]);
        }
        return nums;
    }
};

第二题 重排列数组

    //int* shuffle(int* nums, int numsSize, int n, int* returnSize){
     C 解法
    // int l = numsSize / 2;
    // int * ret = (int *) malloc(2 * n * sizeof(int));
    // for(int i = 0; i < l; i++)
    // {
    //     ret[2 * i] = nums[i];
    //     ret[2 * i + 1] = nums[n + i];
    // }
    // *returnSize = numsSize;
    // return ret;
    //}


class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        vector<int> v(2 * n);
        for(int i = 0; i < n; i++)
        {
            v[2 * i + 1] = nums[n + i];
            v[2 * i] = nums[i];  
        }
        return v;
    }
};

第三题 基于排列构建数组

class Solution {
public:
    vector<int> buildArray(vector<int>& nums) {
        //暴力
        int n = nums.size();
        vector<int> ans;
        for(int & i : nums)
        {
            ans.push_back(nums[i]);
        }
        return ans;
    }
};

class Solution {
public:
    vector<int> buildArray(vector<int>& nums) {
        int n = nums.size();
        // 第一次遍历编码最终值
        for (int i = 0; i < n; ++i){
            nums[i] += 1000 * (nums[nums[i]] % 1000);
        }
        // 第二次遍历修改为最终值
        for (int i = 0; i < n; ++i){
            nums[i] /= 1000;
        }
        return nums;
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/build-array-from-permutation/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

第四题 一维数组动态和

class Solution {
public:
    vector<int> runningSum(vector<int>& nums) {
      暴力
    //    vector<int> runningSum;
    //    int sum = 0;
    //    for(int i = 0; i < nums.size(); i++)
    //    {
    //        sum += nums[i];
    //        runningSum.push_back(sum);
    //    }
    //    return runningSum;
    
        //原地修改算法
        for(int i = 1; i < nums.size(); i++)
        {
            nums[i] += nums[i - 1];
        }
        return nums;

    }
};

第五题 动态口令左旋字符串

class Solution {
public:
    string dynamicPassword(string password, int target) {
        // //暴力 空间复杂度O（n）时间复杂度O（n）
        // int l = password.length();
        // int l1 = l - target;
        // string newpassword = password;
        // for(int i = 0; i < l1; i++)
        // {
        //     newpassword[i] = password[i + target];
        // }
        // for(int i = l1; i < l; i++)
        // {
        //     newpassword[i] = password[i - l1];
        // }
        // return newpassword;

        //局部反转+整体反转 原地修改 空间复杂度为O（1）时间复杂度O（1）
        // reverse(password.begin(), password.begin() + target);
        // reverse(password.begin() + target, password.end());
        // reverse(password.begin(), password.end());
        // return password;


        先整体，在局部也可以
        // reverse(password.begin(), password.end());
        // reverse(password.begin(), password.end() - target);
        // reverse(password.end() - target, password.end());
        // return password;

        //还有一种方法 password.substr()
        // string sub = password.substr(0, target);
        // copy(password.begin() + target, password.end(), password.begin());
        // copy(sub.begin(), sub.end(), password.end() - target);
        // return password;
    }
};

补充一种作法转自英雄算法联盟：

第六题 IP地址无效化

class Solution {
public:
    string defangIPaddr(string address) {
        string ans;
        for(auto & c : address)
        {
            if(c == '.')
            {
                ans.append("[.]")
            }
            else
            {
                ans.push_back(c);
            }
        }  
        return ans;
    }
};

第七题 替换空格——转自英雄算法联盟