leetcode 字符串类型题

1，Vaild Palindrome

 bool isPalindrome(string& s) {
     transform(s.begin(), s.end(), s.begin(), tolower); // 把字符全部转换成小写
     int left = ;
     int right = s.length()-;
     while (left < right) {
         if (!isalnum(s[left])) ++left;
         else if (!isalnum(s[right])) --right;
         else if (s[left] != s[right]) return false;
         else {
             ++left;
             --right;
         }
     }
     return true;
 }

isPalindrome

2，Implement strStr

 int strStr(const string& haystack, const string& needle) { // KMP 算法，BM 算法
     if (needle.empty()) return ;
     const int N = haystack.length() - needle.length();
     for (int i = ; i <= N; ++i) {
         int j = i;  // 源串索引
         int k = ;  // 字串索引
         while (haystack[j] == needle[k] &&  j < haystack.length() && k < needle.length()) {
             ++j;
             ++k;
         }
         if (k == needle.length()) return i;
     }
     return -;
 }

strStr

3，String to Integer(atoi)

 int myAtoi(const string& str) {
     const int n = str.length();
     int sign = ;
     int i = ;
     int num = ;

     while (str[i] == ' ' && i < n) ++i;  // 前面的字符处理
     if (str[i] == '+') {
         sign = ;
         ++i;
     }
     else if (str[i] == '-') {
         sign = -;
         ++i;
     }
     for (; i < n; ++i) {
         if (str[i] < '' || str[i] > '')
             break;
         num = num *  + str[i] - '';

         if (sign ==  && num > INT_MAX)
             return INT_MAX;
         else if (sign == - && num > INT_MIN + )
             return INT_MIN;
     }
     return sign * num;
 }

myAtoi

4，Add Binary

 string addBinary(string a, string b) {  // 思路同 Add Binary(链表类型题) plusOne(数组类型题)
     string result;
     int carry = ;
     reverse(a.begin(), a.end()); // 先反转两个数组，从低位开始相加
     reverse(b.begin(), b.end());
     const int n = a.length() > b.length() ? a.length() : b.length();
     for (int i = ; i < n; ++i) {
         const int ai = i < a.length() ? a[i]-'' : ;
         const int bi = i < b.length() ? b[i]-'' : ;
         int value = (ai + bi + carry) % ;
         carry = (ai + bi + carry) / ;
         result.insert(result.begin(), value + '');
     }
     if (carry == )
         result.insert(result.begin(), '');
     return result;
 }

addBinary

5，Longest Palindromic Substring(未实现)

6，Regular Expression Matching

 bool isMatchI(const char *s, const char *p) {   //递归版   有挑战的一道题目
     if (*p == '\0') return *s == '\0';

     //next char is not '*',then match current character
     if (*(p + ) != '*') {
         if (*p == *s || (*p == '.' && *s != '\0')) { // correctly match
             return isMatchI(s + , p + );
         }
         else {                                      // failed match
             return false;
         }
     }
     else {                                           // next char is '*'
         while (*p == *s || (*p == '.' && *s != '\0')) {
             if (isMatchI(s, p + )) {
                 return true;
             }
             s++;
         }
         return isMatchI(s, p + );
     }
 }

isMatch

7，Wildcard Matching

 bool isMatchII1(const char *s, const char *p) {  // 递归版
     if (*p == '*') {
         while (*p == '*') ++p;  // skip continuous '*'
         if (*p == '\0') return true;
         while (*s != '\0' && !isMatchII1(s, p)) ++s;

         return *s != '\0';
     }
     else if (*p == '\0' || *s == '\0')
         return *p == *s;
     else if (*p == *s || *p == '?')
         return isMatchII1(++s, ++p);
     else
         return false;
 }
 bool isMatchII2(const char *s, const char *p) {  // 迭代版
     bool star = false;
     const char *str = s;  // str 可以变，*str 不能变
     const char *ptr = p;

     while (*str != '\0') {
         switch (*ptr) {
         case '?':
             str++;
             ptr++;
             break;
         case '*':
             star = true;
             while (*ptr == '*') ++p;
             if (*ptr == '\0') return true;
             break;
         default:
             if (*str != *ptr) {
                 if (!star)
                     return false;
                 str++;
             }
         }
     }
     while (*ptr == '*') ++ptr;
     return (*ptr == '\0');

 }

isMatch

8，Longest Common Prefix

 string longestCommonPrefix1(vector<string>& strs) {  // 纵向扫描
     if (strs.empty()) return "";

     for (int index = ; index < strs[].size(); ++index) {  // 选取第一个字符串和其它字符串进行比较
         for (int i = ; i < strs.size(); ++i) {
             if (strs[i][index] != strs[][index])
                 return strs[].substr(, index);
         }
     }
     return strs[];
 }

 string longestCommonPrefix2(vector<string>& strs) { // 横向扫描
     if (strs.empty()) return "";

     int right_most = strs[].size() - ;
     for (size_t i = ; i < strs.size(); ++i) {
         for (int j = ; j <= right_most; ++j) {
             if (strs[i][j] != strs[][j])
                 right_most = j - ;
         }
     }
     return strs[].substr(, right_most + );
 }

longestCommonPrefix

9，Valid Number

 bool isNumber(const char *s) {  //
     char* endptr;
     strtod(s, &endptr);

     if (endptr == s)
         return false;

     for (; *endptr; ++endptr) {
         if (!isspace(*endptr))
             return false;
     }
     return true;
 }

isNumber

10，Integet to Roman

 string intToRoman1(int num) {
     const int radix[] = { , , , , , , , , , , , ,  };
     const string symbol[] = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };

     string roman;
     for (size_t i = ; num > ; ++i) {
         int count = num / radix[i];
         num %= radix[i];
         for (; count > ; --count)
             roman += symbol[i];
     }
     return roman;
 }

 string intToRoman2(int num) {
     string res = "";
     vector<int> val = { , , , , , , , , , , , ,  };
     vector<string> str = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I" };
     for (int i = ; i < val.size(); ++i) {
         while (num >= val[i]) {
             num -= val[i];
             res += str[i];
         }
     }
     return res;
 }

intToRoman

11，Roman to Integer

 int romanToInt(const string& s) {
     int result = ;
     unordered_map<char, int> mapping;
     mapping['I'] = ;
     mapping['V'] = ;
     mapping['X'] = ;
     mapping['L'] = ;
     mapping['C'] = ;
     mapping['D'] = ;
     mapping['M'] = ;

     for (size_t i = ; i < s.size(); i++) {
         if (i >  && (mapping[i] > mapping[i - ])) {
             result += (mapping[s[i]] -  * mapping[s[i - ]]);
         }
         else {
             result += mapping[s[i]];
         }
     }
     return result;
 }

romanToInt

12，Count and Say

 string getNext(const string& s) {
     stringstream ss;
     for (auto i = s.begin(); i != s.end();) {
         auto j = find_if(i, s.end(), bind1st(not_equal_to<char>(), *i));  // 需要看看函数怎么用
         ss << distance(i, j) << *i;
         i = j;
     }
     return ss.str();
 }

 string countAndSay(int n) {
     string s("");
     while (--n) {
         s = getNext(s);
     }
     return s;
 }

countAndSay

13，Anagrams(回文构词法)

 vector<string> anagrams(vector<string>& strs) {
     unordered_map<string, vector<string>> group;
     for ( auto s = strs.begin(); s != strs.end();++s) {
         string key = *s;
         sort(key.begin(), key.end());  // 会修改原数据
         group[key].push_back(*s);
     }
     vector<string> result;
     for (auto it = group.cbegin(); it != group.cend(); ++it) {
         if (it->second.size() > )
             result.insert(result.end(), it->second.begin(), it->second.end());
     }
     return result;
 }

anagrams

14，Simplify Path

 string simplifyPath(const string& path) {
     string dir;
     stack<string> stk;
     string result;

     for (auto i = path.begin(); i != path.end();) {
         ++i;
         auto j = find(i, path.end(), '/');
         dir = string(i, j);   /*  获取两个 / / 之间的内容 */

         if (!dir.empty() && dir !="/" && dir != ".") {
             if (dir == "..") {
                 if (!stk.empty())
                     stk.pop();
             }
             else
                 stk.push(dir);
         }
         i = j;
     }
     //stringstream out;  // 可以用字符串流保存，然后通过 out.str() 转化成字符串返回
     if (stk.empty())
         //out << "/";
         result = "/";
     else {
         while (!stk.empty()) {
             string s = stk.top();
             stk.pop();
             //out << '/' << s;
             result += "/" + s;
         }
     }
     // return out.str();
     return result;
 }

simplifyPath

15，Length of Last Word

 int lengthOfLastWord1(const string& s) {  // STL::find_if,find_if_not,distance
     auto first = find_if(s.rbegin(), s.rend(), isalpha);
     auto last = find_if_not(first, s.rend(), isalpha);
     return distance(first, last);
 }

 int lengthOfLastWord2(const string& s) {
     int len = ;
     for (int i = ; i < s.length(); ++i) {
         if (s[i] != ' ')
             ++len;
         else
             len = ;
     }
     return len;
 }

lengthOfLastWord

c++常用函数

1, split

#include<vector>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

vector<string> split(string str, const char* c) {
    char *cstr, *p;
    vector<string> res;
    cstr = new char[str.length()+];
    strcpy(cstr, str.c_str());
    p = strtok(cstr, c);

    while(p != NULL) {
        res.push_back(p);
        p = strtok(NULL, c);
    }
    delete cstr;  // 释放内存
    return res;
}

int main() {
    string s = "a AND B";
    const char *c = " ";
    vector<string> ans;
    ans = split(s, c);

    for(int i=;i<ans.size();i++) {
        cout << ans[i] << endl;
    }
    return ;
}

split

以上题目来源于：http://www.github.com/soulmachine/leetcode