【LeetCode初级算法】数组篇

从排序数组中删除重复项

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

示例 1:

给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。

你不需要考虑数组中超出新长度后面的元素。 示例 2:

给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

你不需要考虑数组中超出新长度后面的元素。 说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int
i = 0; i < len; i++) {
print(nums[i]); }

解题思路
利用两个快慢指针，一开始两个指针都指向0位置，之后当指针所指的位置数组值相等时，则快指针向后移动一位，不相等时判断两个指针相差是否为1位，如果超过则说明慢指针所指的位置数组有重复元素，将快指针的值赋值过来，两个指针都向前移动一位，最后慢指针所移动过的位置即为去除重复后的数组，长度即为慢指针数值加1。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int length = nums.size();
        if(length == 0)
            return 0;
        int first = 0,last = 0;
        while(last!=length){
            if(nums[first] == nums[last]){
                last++;
            }else{
                first++;
                if(last != first)
                    nums[first] = nums[last];
                last++;
            }
        }
        return first+1;
    }
};

买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 =
5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 示例 2:

输入: [1,2,3,4,5] 输出: 4 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 =
5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 示例 3:

输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

解题思路
参考官方题解

利用丰谷的特点，只用计算每次的峰值和谷值的差，累加即可。

class Solution {
    public:
    int maxProfit(vector<int>& prices) {
        int res=0;
        for(int i = 1; i<prices.size(); ++i){
            if(prices[i] > prices[i-1])
                res += prices[i] - prices[i-1];
        }
        return res;
    }
};

旋转数组

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3 输出: [5,6,7,1,2,3,4] 解释: 向右旋转 1 步:
[7,1,2,3,4,5,6] 向右旋转 2 步: [6,7,1,2,3,4,5] 向右旋转 3 步: [5,6,7,1,2,3,4] 示例
2:

输入: [-1,-100,3,99] 和 k = 2 输出: [3,99,-1,-100] 解释: 向右旋转 1 步:
[99,-1,-100,3] 向右旋转 2 步: [3,99,-1,-100] 说明:

尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。 要求使用空间复杂度为 O(1) 的 原地 算法。

官方题解
两种方法（其他两个On的算法就不考虑了）
1、环状替换

将每一个元素向前移动k位即可得到目标数组，但在数组长度能整除k时会出现上图的情况，因此要把这种情况考虑到算法里。
code

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int temp = 0, count = 0;
        k = k % nums.size();
        for(int start = 0; count < nums.size(); start++){
            int cur = start;
            int prev = nums[start];
            do{
                int next = (cur + k)%nums.size();
                temp = nums[next];
                nums[next] = prev;
                prev = temp;
                cur = next;
                count++;
            }while( start != cur);
        }
    }
};

prev用来做缓冲，实现每一个元素向前移动k个，同时因为不管是那种情况，总体的移动次数都是数组长度，所以用count来做限制，对于整除的情况，用while来检测到回环时跳出，执行下一个元素的移动。
2、使用反转
这个方法基于这个事实：当我们旋转数组 k 次，k 个尾部元素会被移动到头部，剩下的元素会被向后移动。

在这个方法中，我们首先将所有元素反转。然后反转前 k 个元素，再反转后面 n-k 个元素，就能得到想要的结果。
code

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        reverse(nums.begin(), nums.end() - k % nums.size());
        reverse(nums.end() - k % nums.size(), nums.end());
        reverse(nums.begin(), nums.end());
    }
};

存在重复

简单粗暴

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        set<int> help;
        for(int i=0; i<nums.size(); i++){
            if(help.find(nums[i])==help.end())
                help.insert(nums[i]);
            else
                return true;
        }
        return false;
    }
};

只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1] 输出: 1 示例 2:

输入: [4,1,2,1,2] 输出: 4

解题思路
先排序，然后逐个查找
code

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for(int i = 0; i<nums.size();){
            if(i == nums.size() -1 )
                return nums[i];
            if(nums[i] == nums[i+1])
                i = i + 2;
            else
                return nums[i];
        }
        return 0;
    }
};

还有一种很难想到的解法，两个相同的数异或的结果为0，而0与任何数异或是那个数本身，所以直接把所有数遍历异或在一起就是结果。
code

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int res = 0;
        for(int i = 0; i<nums.size();i++){
            res ^= nums[i]; 
        }
        return res;
    }
};

两个数组的交集 II

给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2] 输出: [2,2] 示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4] 输出: [4,9] 说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。 我们可以不考虑输出结果的顺序。 进阶:

如果给定的数组已经排好序呢？你将如何优化你的算法？ 如果 nums1 的大小比 nums2 小很多，哪种方法更优？ 如果 nums2的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

解题思路
简单粗暴，利用一个map存下第一个数组，再遍历一遍第二个数组进行比较。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        map<int, int> help;
        vector<int> res;
        for(int i = 0; i < nums1.size(); i++){
            if(help.find(nums1[i]) == help.end())
                help.insert(make_pair(nums1[i],1));
            else
                help[nums1[i]]++;
        }
        for(int i = 0; i < nums2.size(); i++){
            auto it = help.find(nums2[i]);
            if(it != help.end() && it->second != 0){
                res.push_back(it->first);
                it->second--;
            }
                
        }
        return res;
    }
};

如果数组有序，则采用官方题解的方案：

加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例 1:

输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。 示例 2:

输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        vector<int> res(digits);
        int i = 1;
        if(res[res.size()-1]==9){//如果是连续的几个9结尾，一直加到不是9为止
            while(res[res.size()-i]==9){
                if(res.size()==i&&res[0]==9){//全为9则变成1并加一位
                    res.push_back(0);
                    res[0]=1;
                    return res;
                }   
                res[res.size()-i]=0;
                i++;
            }
            res[res.size()-i]++;//进位到不为9的那一位加1
            return res;
        }else{
            res[res.size()-1]++;//否则末尾加一即可
            return res;
        }
    }
};

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

示例:

输入: [0,1,0,3,12] 输出: [1,3,12,0,0] 说明:

必须在原数组上操作，不能拷贝额外的数组。 尽量减少操作次数。

官方题解
利用两个指针，将非零的元素依次放到数组最前方，同时缩小数组最前方的范围

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        for(int i = 0,j=0;i<nums.size();++i){
            if(nums[i]!=0){
                swap(nums[i],nums[j++]);
            }
        }
    }
};

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]

对于有序数组，可以使用两根指针，分别从头和尾开始，如果两指针所指数之和小于目标值，则头指针++，同理大于则尾指针++。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i = 0,j = nums.size()-1;
        vector<int> res;
        while(i != j){
            int sum = nums[i]+nums[j];
            if(sum == target){
                res.push_back(i);
                res.push_back(j);
                return res;
            }else if(sum < target)
                i++;
            else if(sum > target)
                j--;
        }
        return res;
    }
};

对于无序数组，使用哈希表来做，因为哈希表的特点就是空间换时间，查找对应值的速度为O(1)。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int i = 0;
        int length = nums.size();
        vector<int> res;
        map<int,int> help;
        for(;i < length;++i){
            if(help.count(target - nums[i]) && help[target - nums[i]] != i){
                res.push_back(help[target - nums[i]]);
                res.push_back(i);
                return res;
            }
            help.insert(make_pair(nums[i],i));
        }
        return res;
    }
};

有效的数独

判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。

数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

上图是一个部分填充的有效的数独。

数独部分空格内已填入了数字，空白格用 ‘.’ 表示。

示例 1:

输入:
[ [“5”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”] ] 输出: true 示例 2:

输入:
[ [“8”,“3”,".",".",“7”,".",".",".","."],
[“6”,".",".",“1”,“9”,“5”,".",".","."],
[".",“9”,“8”,".",".",".",".",“6”,"."],
[“8”,".",".",".",“6”,".",".",".",“3”],
[“4”,".",".",“8”,".",“3”,".",".",“1”],
[“7”,".",".",".",“2”,".",".",".",“6”],
[".",“6”,".",".",".",".",“2”,“8”,"."],
[".",".",".",“4”,“1”,“9”,".",".",“5”],
[".",".",".",".",“8”,".",".",“7”,“9”] ] 输出: false 解释: 除了第一行的第一个数字从 5
改为 8 以外，空格内其他数字均与 示例1 相同。
但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。 说明:

一个有效的数独（部分已被填充）不一定是可解的。 只需要根据以上规则，验证已经填入的数字是否有效即可。 给定数独序列只包含数字 1-9 和字符
‘.’ 。 给定数独永远是 9x9 形式的。

参考官方题解下的解答：
利用三个9x10数组分别储存行列和9个小格子，一共只进行一次遍历，其原理是当有一个数出现时，将对应的三个数组中的该数字的位置置一，如果当发现有某一个数组中有对应的位置已经为1，则说明该数字重复，返回false，如果全部遍历完，则返回true。

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        int col[9][10]={0};
        int row[9][10]={0};
        int box[9][10]={0};
        for(int i = 0;i<9;++i){
            for(int j = 0;j<9;j++){
                if(board[i][j] == '.')continue;
                int temp = (int)(board[i][j]-'0');
                if(row[i][temp]==1)return false;
                if(col[j][temp]==1)return false;
                if(box[j/3+(i/3)*3][temp]==1)return false;
            
                row[i][temp]=1;
                col[j][temp]=1;
                box[j/3+(i/3)*3][temp]=1;
            }
        }
        return true;
    }
};

其中判断属于哪一个小格子，参考：

旋转图像

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 90 度。

说明：

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例 1:

给定 matrix = [ [1,2,3], [4,5,6], [7,8,9] ],

原地旋转输入矩阵，使其变为: [ [7,4,1], [8,5,2], [9,6,3] ] 示例 2:

给定 matrix = [ [ 5, 1, 9,11], [ 2, 4, 8,10], [13, 3, 6, 7],
[15,14,12,16] ],

原地旋转输入矩阵，使其变为: [ [15,13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9],
[16, 7,10,11] ]

先转置，再对称翻转。

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int row = matrix.size();
        for(int i = 0; i<row;i++){
            for(int j = i; j<row;j++){
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        
        for(int i = 0; i<row/2;i++){
            for(int j = 0; j<row;j++){
                int temp = matrix[j][i];
                matrix[j][i] = matrix[j][row-i-1];
                matrix[j][row-i-1]= temp;
            }
        }
    }
};