LeetCode经典题目笔记（一）

关于算法与数据结构的相关博文：

KMP算法相关学习资料

二叉树相关练习题（C++）

经典排序算法的C++实现

与字符串有关的一些典型问题的C++解法

一些可以用动态规划（DP）算法解决的问题（C++）

排列组合相关笔试面试题（C++）

与概率相关的算法题C++解法（附证明过程）

二分查找的巧妙运用（C++）

位运算在算法题中的使用（C++）

链表相关练习题（C++）

用实例讲解栈和队列（C++）

一些智力题的C++解法

一、求字符串的最长无重复字符子串的长度。

解法：动态规划。优化方案为：在查找与当前字符相同的字符位置时，可以用一个循环遍历之前的子串，也可以用hash表直接查找，更省时间。

class   Solution {

public :

     int  lengthOfLongestSubstring(string s) {

         int   len = s.size(),start =  0 ;

         if  (s.empty()||len ==  0 )

             return  0 ;

         int  dp[len+ 1 ] = { 0 };

         vector< int > hash( 256 , -1 );

      for  ( int  i =  0 ;i < len;i++) {

             if  (hash[s[i]] >= start)

                start = hash[s[i]]+ 1 ;

            hash[s[i]] = i;

            dp[i+ 1 ] = max(i-start+ 1 ,dp[i]);

        }

         return  dp[len];

    }

};

二、字符串转整数

解法：第一个非空格字符之前的空格忽略；第一个非空格字符是+或-则做相应标记；从第一个非空格字符开始遍历字符串，遇到数字则按规律叠加起来，遇到非数字字符则停止遍历。

class  Solution { 

public : 

    int  myAtoi(string str) { 

        int  positive =  1 ,i = str.find_first_not_of(' '); 

        long  sum =  0 ; 

        if  (str[i] == '+' || str[i] == '-') 

            positive = str[i++] == '-'?- 1 :positive; 

        while  (isdigit(str[i])) { 

            sum = (sum<<1) + (sum<< 3 ) + str[i++]-' 0 '; 

            if  (sum > INT_MAX) 

                return  positive ==  1 ?INT_MAX:INT_MIN; 

        }

        return  positive*sum; 

    }

};

三、判断一个整数是不是回文序列

解法：

class  Solution {
public :

     bool  isPalindrome( int  x) {

         if  (x> 0  && x% 10  ==  0 )

             return false ;

         int  sum =  0 ;

         while  (sum < x) {

            sum = (sum<< 1 )+(sum<< 3 )+x% 10 ;

            x /=  10 ;

        }

         if  (sum == x||sum/ 10  == x)

             return true ;

         else

             return false ;

    }

};

四、求两个已排序数组的中位数

解法：二分查找。

①中位数将所有数据分成个数相等的两个部分，且其中一部分全部大于另一部分；

②同时在两个有序数组中查找合适的划分点，由于要保证划分出的两部分数据个数相等，所以只在其中一个数组的下标中进行二分搜索划分点i，从而确定出另外一个数组中的划分点j；

③为了确保由i推导出的j>=0，需选择长度较小的数组进行二分搜索，这样能确保j合法；

④两个划分点左侧的数据为较小的一半，右侧为较大的一半，所以判断搜索出的划分点是否合法的条件为：较小一半的最大值小于较大一半的最小值。否则更新二分搜索的范围。

class  Solution {
public :

     double  findMedianSortedArrays(vector< int >& nums1, vector< int >& nums2) {

         int  len1 = nums1.size(),len2 = nums2.size(),half_len = (len1+len2+ 1 )/ 2 ;

         if  (len1 > len2) 

             return  findMedianSortedArrays(nums2,nums1);

         int  start =  0 ,end = len1,i,j,numleft,numright;

         while (start <= end) {

            i = (start+end)/ 2 ;

            j = half_len-i;

             if  (i>0&&j<len2&&nums1[i-1] > nums2[j]) 

                end = i-1;

             else if  (j>0&&i<len1&&nums2[j-1] > nums1[i])

                start = i+1;

             else  {

                 if  (i ==  0 ) {

                    numleft = nums2[j- 1 ];

                }

                 else if  (j ==  0 ) {

                    numleft = nums1[i- 1 ];

                }

                 else  {

                    numleft = max(nums1[i- 1 ],nums2[j- 1 ]);

                }

                 break ;

            }

        }

         if  (j == len2 && len1 !=  0 ) numright = nums1[i];

         else if  (i == len1 && len2 !=  0 ) numright = nums2[j];

         else  numright = min(nums1[i],nums2[j]);

         return  (len1+len2)% 2  ==  1 ?(double)numleft:(numleft+numright)/ 2.0 ;

    }

};

五、求字符串的最长回文子串

解法：遍历字符串，以每个字符为中间点向两边扩展比较，记录下最长的回文子串长度和起始位置即可。遇到连续相同的字符要跳过，他们一定包含在同一个回文中。

class  Solution {
public :

    string longestPalindrome(string s) {

         int  len = s.size();

         if  (len <  2 )

             return  s;

         int  mid =  0 ,maxLen =  1 ,start =  0 ;

         while  (mid < len) {

             if  (len-mid <= maxLen/ 2 )

                break;

             int  left = mid,right = mid;

             while  (right < len- 1  && s[right+1] == s[right])

                ++right;

            mid = right+1;

             while  (left >  0  && right < len- 1  && s[left- 1 ] == s[right+ 1 ]) {

                --left;

                ++right;

            }

             if  (right-left+ 1  > maxLen) {

                maxLen = right-left+ 1 ;

                start = left;

            }

        }

         return  s.substr(start,maxLen);

    }

};

六、删除链表中某个结点

解法一：循环到链表尾，依次将结点值向前复制一步。

class  Solution {
public :

     void  deleteNode(ListNode* node) {

         while  (node->next->next) {

            node->val = node->next->val;

            node = node->next;

        }

        node->val = node->next->val;

         delete  node->next;

        node->next =  NULL ;

    }

};

解法二：直接将下一个结点的内容全部复制到当前结点，再删除下一个结点。

class  Solution {
public :

     void  deleteNode(ListNode* node) {

        ListNode* next = node->next;

        *node = *next;

         delete  next;

    }

};

七、求小于正整数n的素数个数

class  Solution {
public :

     int  countPrimes( int  n) {

        vector< int > hmap(n, 1 );

         if  (n <  3 )

             return  0 ;

         int  upper = sqrt(n);

         for  ( int  i =  2 ;i <= upper;++i) {

             if  (hmap[i] ==  0 )

                 continue ;             

        for  ( int  non_prime = i*i;non_prime < n;) {

                hmap[non_prime] =  0 ;

                non_prime += i;

            }

        }

         int  count =  0 ;

         for  (int k =  2 ;k < n;++k)

             if  (hmap[k] ==  1 )

                ++count;

         return  count;

    }

};

八、找到二叉树中所有路径

注意：题中的""不需要输出，""只代表字符串。

解法：递归。

class  Solution {
public :

     void  binaryTreePaths(vector<string>& result, TreeNode* root, string t) {

         if  (!root->left && !root->right) {

            result.push_back(t);

             return ;

        }

         if  (root->left) 

            binaryTreePaths(result, root->left, t + "->" + to_string(root->left->val));

         if  (root->right) 

            binaryTreePaths(result, root->right, t + "->" + to_string(root->right->val));

    }

    vector<string> binaryTreePaths(TreeNode* root) {

        vector<string> result;

         if  (!root)  return  result;

        binaryTreePaths(result, root, to_string(root->val));

         return  result;

    }

};