简单题型
1.两数之和

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        if nums == None or len(nums)<=0:
            return None
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i] + nums[j] == target:
                    return [i,j]

7.反转整数

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        if -10<x<10:
            return x
        s = str(x)
        if s[0] != '-':
            s = s[::-1]
            x = int(s)
        else:
            s = s[1:][::-1]
            x = int(s)
            x = -x
        return x if -2147483648 < x < 2147483647 else 0

9.回文数

class Solution:
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        s = str(x)
        if s[0] == '-':
            return False
        else:
            s1 = s[::-1]
            if s1 == s:
                return True
            else:
                return False

13.罗马数字转整数

class Solution:
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        map = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
        sum = 0
        for i in range(len(s)):
            if i+1 == len(s) or map[s[i]]>=map[s[i+1]]:
                sum += map[s[i]]
            else:
                sum -= map[s[i]]
        return sum

14.最长公共前缀

class Solution:
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if strs == None or len(strs)<=0:
            return ''
        s1 = min(strs)
        s2 = max(strs)
        for i, c in enumerate(s1):
            # 比较是否相同的字符串，不相同则使用下标截取字符串
            if c != s2[i]:
                return s1[:i]
        return s1

8.字符串转整数
利用正则化解决字母索引问题，还可以用ASCll码解决字母，数字的索引问题

class Solution:
    def myAtoi(self, str):
        """
        :type str: str
        :rtype: int
        """
        import re #引入正则化模块

        #正则化中^代表用^后面的开头，[-+]?表示[-+]可以出现，也可以不出现，\d匹配所有数字，\d+数字后面可以连接无数数字，但不能是其他东西，包括空格和字母
        list_s = re.findall(r"^[-+]?\d+", str.strip()) #删除前，后空格。这样容易导致开始碰到字母就为空列表
        #print(list_s)
        if not list_s: 
            return 0  #字母开始列表是空的,直接返回0
        else:
            num =int(''.join(list_s)) #列表转化为字符串，然后转化为整数
            if num >2**31 -1:
                return 2**31 -1
            elif num < -2**31:
                return -2**31
            else:
                return num

283.将0放在列表的所有非0元素之后
思路一：利用O(n)的辅助空间完成0元素的后移
时间复杂度O(n)
空间复杂度O(n)

class Solution:
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        alist = []
        for i in range(len(nums)):
            if nums[i]:
                alist.append(nums[i])
        for i in range(len(alist)):
            nums[i] = alist[i]
        for i in range(len(alist),len(nums)):
            nums[i] = 0

思路二：不使用辅助空间，原地完成0元素后移
时间复杂度O(n)
空间复杂度O(1)

class Solution:
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        k = 0
        for i in range(len(nums)):
            if nums[i]:
                nums[k]=nums[i]
                k+=1
        for i in range(k,len(nums)):
            nums[i] = 0

思路三：直接交换0和非0元素

class Solution:
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        k = 0
        for i in range(len(nums)):
            if nums[i]:
                tmp = nums[k]
                nums[k]=nums[i]
                nums[i] = tmp
                k+=1

27.移除元素
原地移除，O(1)的空间复杂度
思路一：

class Solution:
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        k = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[k] = nums[i]
                k+=1
        return k

思路二：删除元素之后顺序可以改变，不断将最后一个元素替换val的元素即可

class Solution:
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        i = 0
        n = len(nums)
        while i<n:
            if nums[i] == val:
                nums[i] = nums[n-1]
                n -= 1
            else:
                i+=1
        return n

75.颜色分类
思路一：计数排序，简单解法
时间复杂度O(n)
空间复杂度O(k)

class Solution:
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        count = [0]*3
        for i in range(len(nums)):
            if nums[i]==0:
                count[0]+=1
            if nums[i]==1:
                count[1]+=1
            if nums[i]==2:
                count[2]+=1
        index = 0
        for i in range(count[0]):
            nums[index]=0
            index+=1
        for i in range(count[1]):
            nums[index]=1
            index+=1
        for i in range(count[2]):
            nums[index]=2
            index+=1

思路二：三路快排
时间复杂度O(n)
空间复杂度O(1)
只需遍历数组一次

class Solution:
    def sortColors(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        zero = -1
        two = len(nums)
        i = 0
        while i<two:
            if nums[i]==1:
                i+=1
            elif nums[i]==2:
                two -=1
                nums[i],nums[two] = nums[two],nums[i]
            elif nums[i]==0:
                zero +=1
                nums[i],nums[zero] = nums[zero],nums[i]
                i+=1

88.合并两个有序数组
从后向前比较，将nums1和nums2中的最大值放在数组的最后的位置，不断向前遍历

class Solution:
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        if n==0:
            return 
        elif m==0 and n>=0:
            for i in range(n):
                nums1[i]=nums2[i]
        else:
            i = m-1
            j = n-1
            k = m+n-1
            while i>=0 and j>=0:
                if nums1[i]>nums2[j]:
                    nums1[k]=nums1[i]
                    i -=1
                else:
                    nums1[k]=nums2[j]
                    j-=1
                k-=1
            while i>=0:
                nums1[k]=nums1[i]
                i-=1
                k-=1
            while j>=0:
                nums1[k]=nums2[j]
                j-=1
                k-=1