leetcode解题思路---1——30题

2016-6-7完结
1 two sum（easy）

题意：找出数组中两个数之和等于target，并返回数的下标作为结果（只有两个数之和满足条件）
这种题目，有两种思路。（1）最简单的方法，两层的for循环判断两数之和是否等于target，不相等继续循环。相等则返回答案。（2）首先将数组的值与下标之间的映射保存下来。在将数组排序，采用high、low双指针加法，得到结果的方式

2 add two sum（medium）

题意：You are given two linked lists representing two non-negative numbers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8

这道题就是采用大数相加的原理，还有考察了链表操作熟悉程度。第一个数的用链表L1表示，第二个数用L2表示。这个需要考虑到一个进位carry，用bool表示即可。最后终止条件为 carry==false && !L1 && !L2

3Longest Substring Without Repeating Characters（medium）

题意：Given “pwwkew”, the answer is “wke”, with the length of 3. Note that the answer must be a substring。注意了，这道题是求最长的子字符串的长度，而不是序列

思路1：每次循环判断都是独立，不利用前面判断过的信息。利用一个256大小数组，如果有字符出现两次终止当次循环，判断max_length长度。进行n次这样的循环

思路2：利用前面判断的信息。

        for(end=1;endend++)
        {
            flag=0;
            for(now=begin;now<end;now++)
            {
                if(s[now]==s[end])
                {
                    max_length=max(max_length,end-begin);
                    begin=now+1;
                    flag=1;
                    break;

                }
            }
            if(flag==0)
            {
                max_length=max(max_length,end-begin+1);
            }
        }

4 Median of Two Sorted Arrays（hard）

题意：找出两个排序数组的中位数，要求时间复杂度为O(log(m+n))

思路：(try again)

int findKth(vector<int>::iterator A,int m,vector<int>::iterator B,int n,int k)
{
    if(m>n)
        return(findKth(B,n,A,m,k));
    if(m<=0)
        return B[k-1];
    if(n<=0)
        return A[k-1];
    if(k<=1)
        return min(A[0],B[0]);
    int qa=min(m,k/2);
    int qb=k-qa;
    if(A[qa-1]1])
        return findKth(A+qa,m-qa,B,n,k-qa);
    else if(A[qa-1]>B[qb-1])
        return findKth(A,m,B+qb,n-qb,k-qb);
    else
        return A[qa-1];
}
class Solution {
public:
    double findMedianSortedArrays(vector<int> &nums1, vector<int> &nums2) 
    {
        int m=nums1.size();
        int n=nums2.size();
        int k=m+n;

        if(k%2==1)
            return findKth(nums1.begin(),m,nums2.begin(),n,k/2+1);
        else
            return(double(findKth(nums1.begin(),m,nums2.begin(),n,k/2)+findKth(nums1.begin(),m,nums2.begin(),n,k/2+1))/2;

    }
};

5 Longest Palindromic Substring(最长的回文子串)（medium）

思路1：中心扩展法

分为回文子串长度为奇数
回文子串长度为偶数
中心从i=1：n-1，可以得到以i为中心的最长的回文子串的长度

思路2：动态规划法

用一个n*n矩阵保存子串Si,j是否是回文子串
Si,j=0 if(ai!=aj || Si+1,j-1==0)
Si,j=1 if(ai==aj && Si+1,j-1==1)
先要将矩阵Si,i保存为1，Si,j+1的值求出，在进行后续操作

7Reverse Integer easy

思路：要考虑溢出问题,溢出时返回0

8 String to Integer (atoi) easy
题意，讲字符串转为整型数

这道题就是考察大家考虑的全面与否。空格，+/-，‘0-9’，溢出问题

9 Palindrome Number easy
通过高位低位之间比较从而判断这个数是不是回文数

10Regular Expression Matching（hard）
这道题，正则表达式匹配。规则：. 代表任意的一个字符 * 匹配前面字符0个1个或多个.难点就是在于*的匹配

思路：string s, string p
当p为空时，返回s是否为空的bool值
当s为空时，判断p[1]==’*’ true isMatch(s,p.substr(2)); false, return false;

当p.length()>=2 && p[1]==’*’

while(s.length()>0&&p.length()>0 &&(s[0]==p[0] ||p[0]=='.'))
            {
                if(isMatch(s,p.substr(2)))
                    return true;
                s=s.substr(1);
            }
            return isMatch(s,p.substr(2));

else

 if(p[0]!='.' && p[0]!=s[0])
                return false;
            else
                return isMatch(s.substr(1),p.substr(1));

11 Container With Most Water(medium)

这道题挺容易的，从两端可以遍历，直到两个指针相遇为止。求出每次area，与目前的maxarea相比较

14 Longest Common Prefix
题意：找出一组字符串最长的公共前缀
可以两个字符串找到公共前缀
也可以所有字符串每个字符串比较（这个时间更少一点）

15 3Sum （medium）
3个数之和等于0
先对数组进行排序。固定一个数，然后在利用从固定数后的位置的两端求解满足条件之和。完成后，固定数的位置要前进，不只是前进一个位置，而是前进到一个数不等于前一个固定数为止（避免出现同样的三个数答案）

16 Sum Closest（medium）
这一题与15题类似，就是要一个判断条件：若结果等于target，则返回。否则，跟目前最接近的result比较，那个值更接近，若现在计算的更接近则更新result结果

17Letter Combinations of a Phone Number（medium）
题意：给定一个数字字符串，返回所有可能的字母组合
这道题编程之美书上也出现过
思路：将每个数字表示的字符用数组存储起来，0和1都表示空格。再利用两个vector（tmp,result）记录每增加一个数字字符，可以表示的字母组合.result表示进行到第i个数字后，可以表示的字母组合。tmp表示进行到第i+1个数字后的字母表示。

 for(int i=0;ivector<string> temp;
            for(int j=0;j'0'].length();++j)
            {

                for(int k=0;k'0'].at(j));
                }

            }
            result=temp;
        }

19 Remove Nth Node From End of List（easy）

题意：删除链表的倒数第n个结点

思路一：通过两次遍历。第一次得到链表的长度，第二次确定倒数第n个结点前一个结点的位置

思路二：通过双指针实现，双指针在解决链表问题中是非常常见的。首先，创建一个结点，其指针指向head（这样操作对于删除head结点，不用特殊考虑）。快指针比慢指针先走n个结点，然后两个指针一起行动，知道快指针的到达最后一个结点

20 Valid Parentheses（easy）
题意：判断输入的括号是不是合理的

思路：用stack实现。
入栈，只有左括号才能入栈。
出栈，栈顶元素与目前遍历到的元素若是一对。如果右括号没有与栈顶元素配对，则返回false
遍历结束后，若栈为空，则返回true，若不为空，返回false

21 Merge Two Sorted Lists(easy)
题意：将两个有序的链表合并，合并的链表是由以前的链表结点组成的

很简单，就这样了

22 Generate Parentheses （medium） 看看
题意：输入n，表示有n对括号。输出这些括号合理排列的顺序

思路：用回溯法（这种算法思想就是，进行一下步操作返回后，要对改变的变量进行还原）例如下面的代码

stack<int> ss;
void dfs(int n,int i)
{
    if(i==n)
        return;
    ss.push(...);//
    dfs(n,++i);
    ss.pop();//还原
}

这道就是采用这种思想，操作过程中，要保证括号的合理性，从左往右数，左括号的数目要大于等于右括号的数目

string str;
    vector<string> result;
    void dfs(int left,int right,int n)
    {
        if(left==n)
        {
            result.push_back(str.append(n-right,')'));
            str.pop_back();
            int temp=n-right;
            while(--temp>0)
                str.pop_back();
            return;
        }

        str.append("(");
        dfs(left+1,right,n);
        str.pop_back();
        if(right")");
            dfs(left,right+1,n);
            str.pop_back();
        }
    }

23 Merge k Sorted Lists （hard）
思路：采用分治的思想，采用两两合并链表的方式进行

24 Swap Nodes in Pairs（easy）
题意，将两个结点看成一对，交换这两个结点。考察了链表操作的熟悉程度 easy

25 Reverse Nodes in k-Group（hard）
easy，跟24题区别在于判断剩余的链表部分是否够长度k

26 Remove Duplicates from Sorted Array（easy）
easy，利用一个变量记录重复字符个数，也表示后面字符向前移动多少位

27 Remove Element（easy）

28 implement strStr() (easy)

29 Divide Two Integers (easy)
题意：两个整数相除，不使用乘，除，取余操作，如果溢出，返回MAX_INT

思路：用减法实现，将数据类型转化为long long类型，先确定结果的符号。

30 Substring with Concatenation of All Words

写了一遍竟然没有了，伤心，不写了。就是用map保存每个单词出现的次数，从i开始截取单词，判断是不是map中的单词，判断次数是不是符合要求，。。。

第4题和第22题，以后需要再回顾一下，就这样吧