力扣之数组移除元素

移除元素

carl 原文：移除元素

27. 移除元素

//快慢指针：只要不等于val就接受赋值
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int j = 0;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] != val){  
                nums[j++] = nums[i];                                
            }
        }
        return j;
    }    
};

26.删除排序数组中的重复项

//快慢指针：只要快慢指针指向不相等，就接受赋值
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.size()==0)return 0;//测试用例有一个空数组
        int slow = 0;
        for(int fast = 1;fast < nums.size(); fast++){
            if(nums[slow] != nums[fast]){
                nums[++slow] = nums[fast];
            }
        }
        return slow+1;
    }
};

•283.移动零

//快慢指针：只要不等于0就接受赋值，统计接受个数，从下一个到结尾都赋值为0
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow =0;
        for(int fast = 0; fast<nums.size(); fast++){
            if(nums[fast] != 0){
                nums[slow] = nums[fast];    
                slow++;          
            }            
        }
        while(slow<nums.size()){
            nums[slow++] = 0;
        }
    }
};

•844.比较含退格的字符串

/*
第一反应是用一个栈，此处使用string代替栈
时间复杂度:O(n + m)
空间复杂度:O(n + m)
*/
class Solution {
public:
    string rebuilds(string S){
        string s;
        for(int i = 0; i < S.size(); i++){
            if(S[i] !='#'){
                s.push_back(S[i]);
            }
            else{
                if(!s.empty())
                s.pop_back();
            }
        }
        return s;
    }
    bool backspaceCompare(string S, string T) {
        return rebuilds(S) == rebuilds(T);        
    }
};
/*
优化方法（从后向前双指针）
当然还可以有使用 O(1) 的空间复杂度来解决该问题。
同时从后向前遍历S和T（i初始为S末尾，j初始为T末尾），记录#的数量，模拟消除的操作，如果#用完了，就开始比较S[i]和S[j]。
*/
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int endS = s.size()-1, endT = t.size()-1;
        int beginS = 0, beginT = 0;
        while(1){
            while(endS >= 0){
                if(s[endS] =='#') {
                    beginS++;
                }
                else{
                    if(beginS) beginS--;
                    else break;
                }
                endS--;
            }
            while(endT >= 0){
                if(t[endT] == '#') {
                    beginT++;
                }
                else{
                    if(beginT) beginT--;
                    else break;
                }
                endT--;
            }
            if(endS < 0 || endT < 0)break;           // S 或者T 遍历到头了
            if(s[endS] != t[endT])return false;
            endS--,endT--;       
        }
        if(endS == -1 && endT ==-1)return true;
        return false;

    }
};
/*

时间复杂度：O(n + m)
空间复杂度：O(1)

*/

•977.有序数组的平方

//code1:遍历数组使得每个值都是自己的平方，然后使用sort()排序
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(int i = 0; i< nums.size(); i++){
            nums[i] *= nums[i];
        }
        sort(nums.begin(),nums.end());
        return nums;
    }
};

//code2:使用双指针进行比较赋值
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        long int left = 0, right = nums.size() - 1, k = nums.size() - 1;
        vector<int>result(nums.size(),0);
        while(k >= 0){
            if(nums[left]*nums[left] < nums[right]*nums[right]){
                result[k--] = nums[right] * nums[right];
                right--;
            }
            else{
                result[k--] = nums[left] * nums[left];
                left++;
            }
        } 
        return result;
    }
};