第一题

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

暴力法， 通用写法 vs 列表推导式, 看到 leetcode 上的 耗时 时快时慢，也是茫然。。。  这两种方法耗时均为 O(n2)class Solution:def twoSum(self, nums, target):""":type nums: List[int]:type target: int:rtype: List[int]"""for i,v in enumerate(nums):for j in range(i+1,len(nums)):if v+nums[j] == target:return [i,j]else:raise ValueError('未找到这样的数字')# return [[i,j] for i,v in enumerate(nums) for j in range(i+1,len(nums))  if v+nums[j] == target ]nums = [2, 7, 11, 15]
target = 9
s = Solution()
s.twoSum(nums,target)# 列表推导式
class Solution:def twoSum(self, nums, target):""":type nums: List[int]:type target: int:rtype: List[int]"""return [[i,j] for i,v in enumerate(nums) for j in range(i+1,len(nums))  if v+nums[j] == target ]nums = [2, 7, 11, 15]
target = 9
s = Solution()
s.twoSum(nums,target)# 根据阅读提示，改写为 字典 查找法 (两遍遍历哈希表) 缩短 算法耗时 O(n)
class Solution:def twoSum(self, nums, target):""":type nums: List[int]:type target: int:rtype: List[int]"""d = {}[d.update({v:i}) for i,v in enumerate(nums)]for i,v in enumerate(nums):if (target - v) in d and i!= d[target - v]:return [i,d[target - v]]nums = [2, 7, 11, 15]
target = 9
s = Solution()
s.twoSum(nums,target)# 根据提示，遍历一遍 哈希表方法class Solution:def twoSum(self, nums, target):""":type nums: List[int]:type target: int:rtype: List[int]"""d = {}for i,v in enumerate(nums):value = target - vif value in d and d[value] != i:return [d[value],i]d.update({v:i})nums = [2, 7, 11, 15]
target = 9
s = Solution()
s.twoSum(nums,target)总结 ， 可以看到算法依次是 暴力法(嵌套for 两次） O(n2)  --》 两遍遍历哈希表(O(n))  --》一遍遍历哈希表 O(n)

第二题

# 在找到第一个非空字符之前，需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。# 字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它们对于函数没有影响。# 当字符串中的第一个非空字符序列不是个有效的整数；或字符串为空；或字符串仅包含空白字符时，则不进行转换。# 若函数不能执行有效的转换，返回 0。
import re
import math
class Solution:def myAtoi(self, str):""":type str: str:rtype: int"""pattern = re.compile(r'(-?\d+)')res = pattern.search(str)if not res:raise TypeError('Error')else:res = int(res.group(1))if res < math.pow(-2,31) or res > math.pow(2,31):raise ValueError('超出范围啦！')return ress = Solution()print(s.myAtoi('42'))
print(s.myAtoi('-42'))
print(s.myAtoi('4193 with words'))
print(s.myAtoi('words and 987'))
s.myAtoi('-91283472332')ps: 要想通过 leetcode 的 检测呢。。。还是用下面的吧，虽然，都是些 煞笔错误造成不通过# 在找到第一个非空字符之前，需要移除掉字符串中的空格字符。如果第一个非空字符是正号或负号，选取该符号，并将其与后面尽可能多的连续的数字组合起来，这部分字符即为整数的值。如果第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。# 字符串可以在形成整数的字符后面包括多余的字符，这些字符可以被忽略，它们对于函数没有影响。# 当字符串中的第一个非空字符序列不是个有效的整数；或字符串为空；或字符串仅包含空白字符时，则不进行转换。# 若函数不能执行有效的转换，返回 0。
import re
import math
class Solution:def myAtoi(self, str):""":type str: str:rtype: int"""str = str.strip()if not str:return 0pattern = re.compile(r'(^([-|+]?|\d)\d+)')res = pattern.search(str)if not res:return 0 #raise TypeError('Error')else:res = int(res.group(1))if res < math.pow(-2,31):res = int(math.pow(-2,31))    # raise ValueError('超出范围啦！')if res >= math.pow(2,31):res = int(math.pow(2,31))-1return ress = Solution()
s.myAtoi('      -42')

第三题

给定一个 32 位有符号整数，将整数中的数字进行反转。示例 1:输入: 123
输出: 321示例 2:输入: -123
输出: -321
示例 3:输入: 120
输出: 21
注意:假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231,  231 − 1]。根据这个假设，如果反转后的整数溢出，则返回 0。import re
import mathclass Solution:def reverse(self, x):""":type x: int:rtype: int"""if str(x)[0] == '-':s = str(x)[1:]x = int('-'+s[::-1])if math.pow(-2,31) -1 <= int(x) <= math.pow(2,31):return xelse:return 0else:s = str(x)[::-1]x = int(s)if math.pow(-2,31) -1 <= int(x) <= math.pow(2,31):return xelse:return 0

分治法应用， 快排

package com.utils;public class Demo {public static void main(String [] args){int [] array = {3,2,1,4,8,7,6,9};printArray(array);quickSort(array,0,array.length-1);printArray(array);}public static void printArray(int [] array){System.out.print("[");for(int i=0;i<=array.length-1;i++){if(i == array.length-1){System.out.println(array[i]+"]");}else{System.out.print(array[i]+",");}}}public static int [] quickSort(int [] array,int low,int high){if(low<high){int l = low;int r = high;int base = array[l]; // 确定 每次排序的基准值// 右到左，寻找比基准值小的，如果没有r指针一直左移while(l<r && array[r]>=base){r--;}// 跳出了上面的循环从右到左找到了比基准值 base 小的第一个值if(l<r){array[l++] = array[r];}// 左到右，寻找比基准值大的，如果没有 l 指针一直右移while(l<r && array[l]<=base){l++;}// 跳出了上面紧挨着的循环意味着 找到了第一个比基准值大的第一个值if(l<r){// 这里考虑边界问题array[r--] = array[l];// 为何 r 要左移，因为这个坑已经被确定当然继续往前找啦}// 当上面所有操作都已完成意味着 第一趟排序完成，那么最后要把基准值填入array[l]array[l] = base;// 递归调用快排，分别对base 分成的两个区进行同样操作quickSort(array,low,l-1);quickSort(array,r+1,high);}return array;}
}

二分法 查找 前提 列表有序

nums = [1,2,3,4,5,6,7,8,9,10]
def bisearch(n,nums):low, high = 0,len(nums)-1while low<=high:mid = (low + high) //2
#         print(low,'--',mid,'--',high)if n>nums[mid]:low = mid+1elif n<nums[mid]:high = mid -1else:return midreturn 'Not Found!'[bisearch(i,nums) for i in range(1,11)][0, 1, 2, 3, 4, 5, 6, 7, 8, 9]