时间复杂度为O(n)算法

时间复杂度为O(n)算法

双指针算法

（三种双指针算法：相向双指针（reverse:翻转字符串，判断回文数； two sum:两数之和、三数之和；partition:快速排序，颜色排序），背向双指针，同向双指针）

有效回文串 I

给定一个字符串，判断其是否为一个回文串。只考虑字母和数字，并忽略大小写。
https://www.lintcode.com/problem/415/

class Solution {
public:
  
    bool isPalindrome(string &s) {
        // write your code here
        int left = 0;
        int right = s.length()-1;
        while(left < right){
            while(left<right && !isalnum(s[right]))--right;			//isalnum 用于排出非字母和数字的符号
            while(left<right && !isalnum(s[left]))++left;
            if(left<right ){
                if(tolower(s[left]) == tolower(s[right])){
                    --right;
                     ++left;
                }else return false;
            }
        }
       return true;
    }
};

有效回文串 II

给一个非空字符串 s，你最多可以删除一个字符。判断是否可以把它变成回文串

class Solution {
public:
    /**
     * @param s: a string
     * @return: whether you can make s a palindrome by deleting at most one character
     */
    bool validPalindrome(string &s) {
        // Write your code here
        int left =0;
        int right = s.length()-1;
        while(left < right){

            if(s[left] != s[right]){
               return Palindrome(s,left+1,right)||Palindrome(s,left,right-1);
            }
            left++;
            right--;
        }
       return true;

    }
    bool  Palindrome(string &s,int left,int right){
         while(left < right){
            if(left < right && s[left] != s[right]){
                return false;
            }
            left++;
            right--;
        }
       return true;
    } 
};

两整数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

哈希表解法

时间复杂度和空间复杂度均为O(n)

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        
        map<int,int> counters;
        int len = nums.size();
        for(int i=1; i<len; i++){
            map<int,int>::iterator temp = counters.find(target-nums[i]);
            if(temp != counters.end()){
                return {temp->second,i};
            }
            counters[nums[i]] = i;
        }
        return {};
    }
};

双指针做法

如果最开始数组有序，可以利用 数组最大值+最小值和target的关系进行筛选，这样空间复杂度直接降到1，但是如果没有序的话，就要对原值进行排序，所浪费的空间和时间比起哈希表来讲，得不偿失。

---

后续更新：
打擂台算法
单调栈算法
单调队列算法