leetCode (一) 数组

leetcode: 283e , 26e , 27e, 80m

75. sort colors
- 难度: Medium
- 特征: 数据基数小

方法一: 系统库排序算法(题目排除),时间复杂度O(NlonN);

方法二: 基数排序,两次扫描数组,时间复杂度O(N),空间复杂度O(1);

void sortColors(vector<int>& nums) {
    int cnt[3] = {0};
    int size = nums.size();
    for(int i=0; i < size;i++){
         cnt[nums[i]]++;
    }
    int j=0;
    while(cnt[0]--){
        nums[j++] = 0;
    }
    while(cnt[1]--){
        nums[j++] = 1;
    }
    while(cnt[2]--){
        nums[j++] = 2;
    }
} 

方法三: 三路快速排序,时间复杂度O(N),空间复杂度O(1);

void sortColors(vector<int>& nums) {
//[0,zero]为0,[two,n-1]为2
   int zero = -1, two = nums.size() ;
   for(int i = 0; i < two; i++){
        if(nums[i] == 0)
            swap(nums[++zero],nums[i]);
        if(nums[i] == 2)
            swap(nums[--two],nums[i--]);
   }
} 

88. Merge Sorted Array
- 难度: Easy;

方法:由于要在nums1数组上归并,可以采用倒置归并,如果num2归并完了整个算法即完成,如果num1线归并完成,还需要将num2倒插到num1中

void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
    int i=m-1;
    int j=n-1;
    int k = m+n-1;
    while(i>=0 && j>=0){
        if(nums1[i] < nums2[j])
            nums1[k--] = nums2[j--];
        else nums1[k--] = nums1[i--];
    }
    while(j>=0) nums1[k--]= nums2[j--];
}

215. Kth Largest Element in an Array
- 难度: medium

方法一: 循环采用快排的分组,平均时间复杂度O(N);

int partition(vector<int>& nums,int left ,int right){
   int v = nums[left];
   int j = left;
   for(int i = left+1;i<= right ;++i){
       if(nums[i] > v)
           swap(nums[++j],nums[i]);
   }
   swap(nums[j],nums[left]);
   return j;
}

int findKthLargest(vector<int>& nums, int k) {
    int left = 0,right = nums.size() -1;
    while(true){
        int pos = partition(nums,left,right);
        if(pos == k-1 ) return nums[pos];
        if(pos > k-1) right = pos-1;
        else left = pos+1;
    }
}

方法二: 采用最大堆,平均时间复杂度为O(N);

167. Two Sum 2
- 难度: easy

方法:对撞指针,头尾两个指针,如果和小于target,头指针下移,如果和大于target,尾指针上移,直到等于target,时间复杂度O(N);

vector<int> twoSum(vector<int>& numbers, int target) {
        int left = 0, right = numbers.size()-1;
        while (numbers[left] + numbers[right] != target) {
            if (numbers[left] + numbers[right] < target)
                left++;
            else
                right--;
        }
        vector<int> ans;
        ans.push_back(++left);
        ans.push_back(++right);
        return ans;
    }

125. Valid Palindrome
- 难度: easy

方法:对撞指针,与167T 解法一样,时间复杂度为O(N),头文件中的函数需要了解和使用,isalnum(c): 当c时字母或数字时为真, tolow(c):如果c是大写字母则输出其小写字母,否则原样输出c

 bool isPalindrome(string s) {
        if(s.empty()) return true;
        int left = 0 , right = s.size()-1;
        while(left < right){
            while(!isalnum(s[left]) && left < right)
                left++;
            while(!isalnum(s[right]) && left < right)
                right--;
            if(tolower(s[left++]) != tolower(s[right--]))
                return false;
        }
        return true;
    }

344. Reverse String
- 难度: easy

方法:方法同125T 解法一样,时间复杂度为O(N),空间复杂度O(1);
方法二: 反向复制字符串,时间复杂度为O(N),空间复杂度O(N);

class Solution {
public:
    string reverseString(string s) {
        int left=0,right = s.size()-1;
        while(left < right)
            swap(s[left++],s[right--]);
        return s;
    }
};

345. Reverse Vowels of a String
- 难度: easy

方法: find_first_of函数可以找到第一个元音字母

string reverseVowels(string s) {
        int left=0, right = s.size()-1;
        while(left < right){
            left = s.find_first_of("aeiouAEIOU",left);
            right = s.find_last_of("aeiouAEIOU",right);
            if(left < right)
                 swap(s[left++],s[right--]);
        }
        return s;
    }

11. Container With Most Water
- 难度: medium

方法: 根据木桶原理,装多少水左右两边最低的那个墙起决定性作用,所以可以设置对撞指针,左右谁低就移动谁,然后与当前最大水量比较,保存最大值,直到指针汇合

int maxArea(vector<int>& height) {
        int left = 0,right = height.size()-1;
        int ans = 0;
        while(left < right){
            ans = max(ans,min(height[left],height[right])*(right-left) );
            height[left] < height[right] ? left++ : right--;
        }
        return ans;
    }