├── 1. 两数之和 ├── 100. 相同的树 ├── 101. 对称二叉树 ├── 102. 二叉树的层次遍历 ├── 104. 二叉树的最大深度 ├── 107. 二叉树的层次遍历 II ├── 108. 将有序数组转换为二叉搜索树 ├── 11. 盛最多水的容器 ├── 110. 平衡二叉树 ├── 111. 二叉树的最小深度 ├── 112. 路径总和 ├── 118. 杨辉三角 ├── 119. 杨辉三角 II ├── 121. 买卖股票的最佳时机 ├── 122. 买卖股票的最佳时机 II ├── 125. 验证回文串 ├── 13. 罗马数字转整数 ├── 136. 只出现一次的数字 ├── 14. 最长公共前缀 ├── 141. 环形链表 ├── 144. 二叉树的前序遍历 ├── 145. 二叉树的后序遍历 ├── 155. 最小栈 ├── 160. 相交链表 ├── 167. 两数之和 II - 输入有序数组 ├── 169. 求众数 ├── 172. 阶乘后的零 ├── 189. 旋转数组 ├── 190. 颠倒二进制位 ├── 191. 位1的个数 ├── 198. 打家劫舍 ├── 2. 两数相加 ├── 20. 有效的括号 ├── 202. 快乐数 ├── 203. 移除链表元素 ├── 204. 计数质数 ├── 205. 同构字符串 ├── 206. 反转链表 ├── 21. 合并两个有序链表 ├── 217. 存在重复元素 ├── 219. 存在重复元素 II ├── 226. 翻转二叉树 ├── 231. 2的幂 ├── 234. 回文链表 ├── 235. 二叉搜索树的最近公共祖先 ├── 237. 删除链表中的节点 ├── 242. 有效的字母异位词 ├── 257. 二叉树的所有路径 ├── 258. 各位相加 ├── 26. 删除排序数组中的重复项 ├── 263. 丑数 ├── 268. 缺失数字 ├── 27. 移除元素 ├── 278. 第一个错误的版本 ├── 28. 实现strStr() ├── 283. 移动零 ├── 290. 单词规律 ├── 292. Nim 游戏 ├── 3. 无重复字符的最长子串 ├── 303. 区域和检索 - 数组不可变 ├── 326. 3的幂 ├── 342. 4的幂 ├── 344. 反转字符串 ├── 345. 反转字符串中的元音字母 ├── 349. 两个数组的交集 ├── 35. 搜索插入位置 ├── 350. 两个数组的交集 II ├── 367. 有效的完全平方数 ├── 371. 两整数之和 ├── 374. 猜数字大小 ├── 383. 赎金信 ├── 387. 字符串中的第一个唯一字符 ├── 389. 找不同 ├── 404. 左叶子之和 ├── 409. 最长回文串 ├── 412. Fizz Buzz ├── 414. 第三大的数 ├── 429. N叉树的层序遍历 ├── 434. 字符串中的单词数 ├── 437. 路径总和 III ├── 441. 排列硬币 ├── 448. 找到所有数组中消失的数字 ├── 455. 分发饼干 ├── 459. 重复的子字符串 ├── 461. 汉明距离 ├── 476. 数字的补数 ├── 485. 最大连续1的个数 ├── 5. 最长回文子串 ├── 509. 斐波那契数 ├── 53. 最大子序和 ├── 543. 二叉树的直径 ├── 557. 反转字符串中的单词 III ├── 58. 最后一个单词的长度 ├── 617. 合并二叉树 ├── 66. 加一 ├── 67. 二进制求和 ├── 69. x 的平方根 ├── 7. 整数反转 ├── 70. 爬楼梯 ├── 704. 二分查找 ├── 8. 字符串转换整数 (atoi) ├── 83. 删除排序链表中的重复元素 ├── 88. 合并两个有序数组 ├── 9. 回文数 ├── 94. 二叉树的中序遍历 ├── README.md ├── 二维数组中的查找 ├── 冒泡排序 ├── 利用堆获得 top K ├── 剑指-用两个栈实现队列 ├── 堆排序算法 ├── 归并排序 ├── 快速排序 ├── 推箱子问题 ├── 插入排序 ├── 选择排序 ├── 面试指南-1.1 最小栈 └── 面试指南-1.2 由两个栈组成的队列 /1. 两数之和: -------------------------------------------------------------------------------- 1 | 1、两次循环 2 | class Solution(object): 3 | def twoSum(self, nums, target): 4 | """ 5 | :type nums: List[int] 6 | :type target: int 7 | :rtype: List[int] 8 | """ 9 | result = [] 10 | length = len(nums) 11 | for i in range(length): 12 | for j in range(i+1,length): 13 | if nums[i] + nums[j] == target: 14 | result.append(i) 15 | result.append(j) 16 | break 17 | return result 18 | 19 | 2、字典 20 | class Solution(object): 21 | def twoSum(self, nums, target): 22 | """ 23 | :type nums: List[int] 24 | :type target: int 25 | :rtype: List[int] 26 | """ 27 | dic = {} 28 | for ind, val in enumerate(nums): 29 | dic[val] = ind 30 | for i, val in enumerate(nums): 31 | j = dic.get(target - val) 32 | if j is not None and i!=j: 33 | return [i,j] 34 | break; 35 | 36 | -------------------------------------------------------------------------------- /100. 相同的树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | def isSameTree(self, p: TreeNode, q: TreeNode) -> bool: 10 | #用递归，分别比较两个子树 11 | if p == None and q == None: 12 | return True 13 | elif p != None and q != None: 14 | if p.val == q.val: 15 | return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right) 16 | else: 17 | return False 18 | else: 19 | return False 20 | -------------------------------------------------------------------------------- /101. 对称二叉树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution: 9 | #判断两个子树是否镜像对称,即左子树的右子树与右子树的左子树也镜像对称 10 | def issame(self, p, q): 11 | if p != None and q != None: 12 | if p.val == q.val: 13 | return self.issame(p.right, q.left) and self.issame(p.left, q.right) 14 | else: 15 | return False 16 | elif p == None and q == None: 17 | return True 18 | else: 19 | return False 20 | 21 | 22 | 23 | def isSymmetric(self, root: TreeNode) -> bool: 24 | if root == None: 25 | return True 26 | return self.issame(root.left, root.right) 27 | 28 | -------------------------------------------------------------------------------- /102. 二叉树的层次遍历: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def levelOrder(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: List[List[int]] 13 | """ 14 | if not root: 15 | return 16 | res = [] 17 | cur_level = [root] #存放当前层的node 18 | while cur_level: 19 | temp = [] #存放当前层的val 20 | next_level = [] #存放下一层的node 21 | for i in cur_level: 22 | temp.append(i.val) 23 | if i.left: 24 | next_level.append(i.left) 25 | if i.right: 26 | next_level.append(i.right) 27 | res.append(temp) 28 | cur_level = next_level 29 | return res 30 | -------------------------------------------------------------------------------- /104. 二叉树的最大深度: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def maxDepth(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: int 13 | """ 14 | #递归算法，计算左右子树的深度 15 | if root == None: 16 | return 0 17 | #左右子树的深度 18 | lef = self.maxDepth(root.left) 19 | rig = self.maxDepth(root.right) 20 | #最深的深度+1（根节点） 21 | return max(lef,rig)+1 22 | -------------------------------------------------------------------------------- /107. 二叉树的层次遍历 II: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def levelOrderBottom(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: List[List[int]] 13 | """ 14 | if root == None: 15 | return [] 16 | cur_root = [root] #从上至下，存放每一层的树节点 17 | alist = [] #存放最后的输出列表 18 | 19 | #从上至下遍历树节点 20 | while cur_root: 21 | #存放当前层节点 22 | current_list = [] 23 | #存放下一层的节点 24 | next_list = [] 25 | for node in cur_root: 26 | current_list.append(node.val) 27 | if node.left != None: 28 | next_list.append(node.left) 29 | if node.right != None: 30 | next_list.append(node.right) 31 | cur_root = next_list 32 | #将每一层节点，压入最后的输出列表alist 33 | alist.append(current_list) 34 | #反序输出，原来顺序是 [3],[9,20],[15,7] 35 | return alist[::-1] 36 | -------------------------------------------------------------------------------- /108. 将有序数组转换为二叉搜索树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | ''' 8 | 运用递归算法 9 | 1.就是先找到中间元素，创建根节点 10 | 2.将mid左边的节点，建立好一个子树插到root的左子树上 11 | 3.将mid右边的节点，建立好一个子树插到root的右子树上 12 | ''' 13 | 14 | 15 | class Solution(object): 16 | def sortedArrayToBST(self, nums): 17 | """ 18 | :type nums: List[int] 19 | :rtype: TreeNode 20 | """ 21 | if len(nums) == 0: 22 | return None 23 | length = len(nums) 24 | mid = length//2 25 | root = TreeNode(nums[mid]) 26 | root.left = self.sortedArrayToBST(nums[:mid]) 27 | root.right = self.sortedArrayToBST(nums[mid+1:]) 28 | return root 29 | -------------------------------------------------------------------------------- /11. 盛最多水的容器: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def maxArea(self, height): 3 | """ 4 | :type height: List[int] 5 | :rtype: int 6 | """ 7 | """ 8 | 面积 = (j-i) * min(height[i],height[j]) 9 | 如果值大的指针向内移动，距离一定减小，高度为值小的，因此面积一定减小。 10 | 而我们要求最大的面积，因此值大的指针不动，而值小的指针向内移动遍历即可。 11 | """ 12 | i = 0 13 | j = len(height)-1 14 | max_area = 0 15 | while (i < j): 16 | area = (j-i) * min(height[i],height[j]) 17 | max_area = max(area, max_area) 18 | if height[i] <= height[j]: 19 | i += 1 20 | else: 21 | j -= 1 22 | return max_area 23 | -------------------------------------------------------------------------------- /110. 平衡二叉树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | 10 | def maxlength(self,node): 11 | if node == None: 12 | return 0 13 | left = self.maxlength(node.left) 14 | right = self.maxlength(node.right) 15 | if left == -1 or right == -1 or abs(left-right)>1: 16 | return -1 17 | 18 | return max(left,right)+1 19 | 20 | def isBalanced(self, root): 21 | """ 22 | :type root: TreeNode 23 | :rtype: bool 24 | """ 25 | if self.maxlength(root) == -1: 26 | return False 27 | else: 28 | return True 29 | -------------------------------------------------------------------------------- /111. 二叉树的最小深度: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def minDepth(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: int 13 | """ 14 | #注意[1,2]这个情况，深度为2 15 | if root == None: 16 | return 0 17 | #分为四种情况，1.左右两个子树都存在 2.只有左子树存在 3.只有右子树存在 4.只有一个根节点 18 | if root.left and root.right: 19 | return min(self.minDepth(root.left),self.minDepth(root.right))+1 20 | elif root.left: 21 | return self.minDepth(root.left) + 1 22 | elif root.right: 23 | return self.minDepth(root.right) + 1 24 | else: 25 | return 1 26 | -------------------------------------------------------------------------------- /112. 路径总和: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def hasPathSum(self, root, sum): 10 | """ 11 | :type root: TreeNode 12 | :type sum: int 13 | :rtype: bool 14 | """ 15 | #这道题不断调用递归即可 16 | if root == None: 17 | return False 18 | if root.left == None and root.right == None: 19 | return root.val == sum 20 | #对根节点的左右子树进行递归 21 | return self.hasPathSum(root.left,sum-root.val) or self.hasPathSum(root.right,sum-root.val) 22 | -------------------------------------------------------------------------------- /118. 杨辉三角: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def generate(self, numRows: int) -> List[List[int]]: 3 | #动态规划法，每一层的数组为numRows[i] 4 | # 5 | if numRows == 0: 6 | return [] 7 | #首先建立一个所有元素都是1的数组 例如：[1]*5 为 [1,1,1,1,1] 8 | res = [[1]*i for i in range(1,numRows+1)] 9 | for i in range(2,len(res)): 10 | for j in range(i+1): 11 | if j == 0 or j == i: 12 | res[i][j] = 1 13 | else: 14 | value = res[i-1][j-1] + res[i-1][j] 15 | res[i][j] = value 16 | return res 17 | -------------------------------------------------------------------------------- /119. 杨辉三角 II: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def getRow(self,rowIndex): 3 | """ 4 | :type rowIndex: int 5 | :rtype: List[int] 6 | """ 7 | #递归法 8 | res = [[1]*n for n in range(1,rowIndex+2)] 9 | for i in range(2,rowIndex+1): 10 | print(i) 11 | for j in range(i+1): 12 | if j == 0 or j == i: 13 | pass 14 | else: 15 | res[i][j] = res[i-1][j-1] + res[i-1][j] 16 | return res[rowIndex] 17 | -------------------------------------------------------------------------------- /121. 买卖股票的最佳时机: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def maxProfit(self, prices: List[int]) -> int: 3 | """ 4 | 很巧妙的，这道题也是DP思想： 5 | 前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格} 6 | """ 7 | if len(prices) <= 1: 8 | return 0 9 | 10 | 11 | dp_max = {} 12 | dp_min = {} 13 | dp_max[0] = 0 14 | dp_min[0] = prices[0] 15 | for i in range(1,len(prices)): 16 | #前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格 17 | dp_max[i] = max(dp_max[i-1],prices[i]-dp_min[i-1]) 18 | #前i天的最小价格 = min{前i-1天的最小收价格，第i天的价格 19 | dp_min[i] = min(dp_min[i-1],prices[i]) 20 | 21 | #求最大收益 22 | max_p = dp_max[0] 23 | for i in range(len(prices)): 24 | if dp_max[i] > max_p: 25 | max_p = dp_max[i] 26 | return max_p 27 | -------------------------------------------------------------------------------- /122. 买卖股票的最佳时机 II: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def maxProfit(self, prices): 3 | """ 4 | :type prices: List[int] 5 | :rtype: int 6 | """ 7 | #本题可以在同一天买入和卖出，因此只要当天票价比昨天的高就可以卖出 8 | length = len(prices) 9 | if length == 0: 10 | return 0 11 | count = 0 12 | for i in range(1,length): 13 | if prices[i] > prices[i-1]: 14 | count += prices[i] - prices[i-1] 15 | return count 16 | -------------------------------------------------------------------------------- /125. 验证回文串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPalindrome(self, s): 3 | """ 4 | :type s: str 5 | :rtype: bool 6 | """ 7 | new = [] 8 | for char in s: 9 | #注意“=”号，包括0，9，a,z 10 | #注意char为字符，将数字0，9换成字符 11 | if "0" <= char <= "9": 12 | new.append(char) 13 | elif "a" <= char <= "z": 14 | new.append(char) 15 | elif "A" <= char <= "Z": 16 | new.append(char.lower()) 17 | print(new) 18 | reverse = new[::-1] 19 | return new == reverse 20 | -------------------------------------------------------------------------------- /13. 罗马数字转整数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def romanToInt(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | roman_num_map = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000} 8 | ans = 0 9 | 10 | for i in range(len(s)): 11 | if i+1 < len(s) and roman_num_map[s[i]] < roman_num_map[s[i+1]]: 12 | ans -= roman_num_map[s[i]] 13 | else: 14 | ans += roman_num_map[s[i]] 15 | return ans 16 | -------------------------------------------------------------------------------- /136. 只出现一次的数字: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def singleNumber(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | ''' 8 | 异或： 1. 相同为0 9 | 2. 0与任何数异或都等于那个数 0^a = a 10 | 3. a^b^a = a^a^b = b 满足交换律 11 | ''' 12 | a = 0 13 | for i in nums: 14 | a = a^i 15 | return a 16 | -------------------------------------------------------------------------------- /14. 最长公共前缀: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestCommonPrefix(self, strs): 3 | """ 4 | :type strs: List[str] 5 | :rtype: str 6 | """ 7 | if not strs: 8 | return "" 9 | result = '' 10 | #这里使用python的max()与min()函数求出最大与最小串，再比较最大最小串的重合子串 11 | str_max = max(strs) 12 | str_min = min(strs) 13 | for i in range(len(str_min)): 14 | if str_min[i] == str_max[i]: 15 | result += str_min[i] 16 | else: 17 | break 18 | return result 19 | -------------------------------------------------------------------------------- /141. 环形链表: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | def hasCycle(self, head): 9 | """ 10 | :type head: ListNode 11 | :rtype: bool 12 | """ 13 | #使用快慢指针，若指针相遇则判断有环 14 | #快指针速度是慢指针的两倍。终止条件是快指针指向None或者快慢指针相等。想象成两匹🐎在环形跑道上追逐，只要速度不一样，迟早相遇 15 | #p:慢指针 q:快指针 16 | if head == None: 17 | return False 18 | p = head 19 | q = head 20 | while q: 21 | if q.next == None: 22 | return False 23 | p = p.next 24 | q = q.next.next 25 | 26 | if p == q: 27 | return True 28 | return False 29 | -------------------------------------------------------------------------------- /144. 二叉树的前序遍历: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def preorderTraversal(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: List[int] 13 | """ 14 | res = [] 15 | def helper(node): 16 | if not node: 17 | return 18 | res.append(node.val) 19 | helper(node.left) 20 | helper(node.right) 21 | helper(root) 22 | return res 23 | 24 | -------------------------------------------------------------------------------- /145. 二叉树的后序遍历: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def postorderTraversal(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: List[int] 13 | """ 14 | res = [] 15 | def helper(node): 16 | if not node: 17 | return 18 | helper(node.left) 19 | helper(node.right) 20 | res.append(node.val) 21 | helper(root) 22 | return res 23 | -------------------------------------------------------------------------------- /155. 最小栈: -------------------------------------------------------------------------------- 1 | class MinStack: 2 | 3 | def __init__(self): 4 | """ 5 | initialize your data structure here. 6 | """ 7 | #定义一个列表 8 | self.stack = [] 9 | 10 | #push(x) -- 将元素 x 推入栈中。 11 | def push(self, x: int) -> None: 12 | self.stack.append(x) 13 | 14 | #pop() -- 删除栈顶的元素。 15 | def pop(self) -> None: 16 | length = len(self.stack) 17 | self.stack = self.stack[:length-1] 18 | 19 | #top() -- 获取栈顶元素。 20 | def top(self) -> int: 21 | return self.stack[-1] 22 | 23 | #getMin() -- 检索栈中的最小元素。 24 | def getMin(self) -> int: 25 | return min(self.stack) 26 | 27 | 28 | # Your MinStack object will be instantiated and called as such: 29 | # obj = MinStack() 30 | # obj.push(x) 31 | # obj.pop() 32 | # param_3 = obj.top() 33 | # param_4 = obj.getMin() 34 | -------------------------------------------------------------------------------- /160. 相交链表: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | def getIntersectionNode(self, headA, headB): 9 | """ 10 | :type head1, head1: ListNode 11 | :rtype: ListNode 12 | 评论区一个很巧妙的方法，使两个链表到达相等位置时走过的是相同的距离 13 | 链表1的长度是x1+y，链表2的长度是x2+y，我们同时遍历链表1和链表2，到达末尾时，再指向另一个链表。 14 | 则当两链表走到相等的位置时：x1+y+x2 = x2+y+x1 15 | """ 16 | p = headA 17 | q = headB 18 | while p!=q: 19 | p = p.next if p else headB 20 | q = q.next if q else headA 21 | return p 22 | -------------------------------------------------------------------------------- /167. 两数之和 II - 输入有序数组: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def twoSum(self, numbers, target): 3 | """ 4 | :type numbers: List[int] 5 | :type target: int 6 | :rtype: List[int] 7 | """ 8 | """ 9 | 双指针法 10 | left指针从左往右扫，right指针从右往左扫 11 | 如果numbers[left]+numbers[right]==target说明匹配 输出left+1和right+1 (下标从1开始，所以加一) 12 | 如果numbers[left]+numbers[right]target 说明两数之和需要减少 右边指针忘左移（数组升序排列） 14 | """ 15 | length = len(numbers) 16 | left = 0 17 | right = length-1 18 | while left < right: 19 | if numbers[left] + numbers[right] == target: 20 | return [left+1,right+1] 21 | if numbers[left] + numbers[right] < target: 22 | left = left + 1 23 | if numbers[left] + numbers[right] > target: 24 | right = right - 1 25 | -------------------------------------------------------------------------------- /169. 求众数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def majorityElement(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | #为列表中的每一个数创建字典，每出现一次，字典的value+1 8 | #注：d.get(num,0)的使用，d.get(num,0)返回字典d中num元素对应的值,若无，则进行初始化 9 | d = {} 10 | for num in nums: 11 | d[num] = d.get(num,0) + 1 12 | if d[num] > len(nums)/2: 13 | return num 14 | -------------------------------------------------------------------------------- /172. 阶乘后的零: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def trailingZeroes(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | #阶乘的结果尾数有几个零，转换为阶乘中的数需要包含 2 和 5 这两个组合的数 8 | #每有一对2*5存在，则有一个0 9 | #又因为 5 的个数一定比 2 少，问题简化为计算 5 的个数即可 10 | res = 0 11 | while n >= 5: 12 | res += n/5 13 | n = n/5 14 | return res 15 | -------------------------------------------------------------------------------- /189. 旋转数组: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def rotate(self, nums, k): 3 | 4 | """ 5 | :type nums: List[int] 6 | :type k: int 7 | :rtype: None Do not return anything, modify nums in-place instead. 8 | """ 9 | """ 10 | 反转法 11 | 1.将列表反转 12 | 2.将前k个元素反转 前半部分 13 | 3.将后n-k个元素反转 后半部分 14 | """ 15 | #这是让你直接改，不是返回新数组!!!!!!，给nums[::]赋值 16 | #考虑k>数组长度的情况，比如[1,2],3!!!!!!!!! 17 | length = len(nums) 18 | k = k%length #保证k 0 : 10 | res <<= 1 11 | res += n&1 12 | n >>= 1 13 | count -= 1 14 | 15 | return int(bin(res),base = 2) 16 | -------------------------------------------------------------------------------- /191. 位1的个数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def hammingWeight(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | #十进制转二进制的方式。每次对 2 取余判断是否是 1，是的话就 count = count + 1 8 | count = 0 9 | n = bin(n) 10 | print(n) 11 | #注意：c为字符,判断c是否为'1' 12 | for c in n: 13 | if c == '1': 14 | count += 1 15 | return count 16 | -------------------------------------------------------------------------------- /198. 打家劫舍: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def rob(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | #动态规划问题 8 | #思路：当前最大的累计收益= max(前一家的收益，前前一家的收益加上当前的收益) 9 | if len(nums) == 0: 10 | return 0 11 | if len(nums) == 1: 12 | return nums[0] 13 | 14 | if len(nums) == 2: 15 | return max(nums[0],nums[1]) 16 | 17 | dp = {} 18 | dp[0] = nums[0] 19 | dp[1] = max(nums[0], nums[1]) 20 | 21 | 22 | for i in range(2,len(nums)): 23 | dp[i] = max(dp[i-1],dp[i-2]+nums[i]) 24 | return dp[i] 25 | -------------------------------------------------------------------------------- /2. 两数相加: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | def addTwoNumbers(self, l1, l2): 9 | """ 10 | :type l1: ListNode 11 | :type l2: ListNode 12 | :rtype: ListNode 13 | """ 14 | #初始化新节点 15 | re = ListNode(0) 16 | r = re #指针 17 | carry = 0 18 | 19 | while(l1 or l2): 20 | x = l1.val if l1 else 0 21 | y = l2.val if l2 else 0 22 | s = x+y+carry 23 | carry = s//10 24 | r.next = ListNode(s%10) 25 | #指针后移 26 | r = r.next 27 | if (l1 != None): 28 | l1 = l1.next 29 | if (l2 != None): 30 | l2 = l2.next 31 | 32 | if (carry > 0): 33 | r.next = ListNode(1) 34 | return re.next 35 | -------------------------------------------------------------------------------- /20. 有效的括号: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isValid(self, s: str) -> bool: 3 | while '()' in s or '{}' in s or '[]' in s: 4 | s = s.replace('()','') 5 | s = s.replace('{}','') 6 | s = s.replace('[]','') 7 | #如果s为空串则返回True 8 | return s == '' 9 | -------------------------------------------------------------------------------- /202. 快乐数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | exist = [] 3 | def isHappy(self, n): 4 | """ 5 | :type n: int 6 | :rtype: bool 7 | """ 8 | #注意 判断退出的条件 ： 将每次得到的数放入列表，如果已存在 说明该数进入死循环，是不快乐数 9 | #如果陷入死循环会报错，因此这里用 Python 的集合对中间数做了存储，如果发现计算出来的数之前曾经出现过，就说明已经进入了不快乐循环，此时返回 False 10 | already_exist = set() 11 | while n != 1: 12 | num = 0 13 | while n > 0: 14 | num += (n%10)**2 15 | n = n/10 16 | 17 | 18 | if num in already_exist: 19 | return False 20 | else: 21 | already_exist.add(num) 22 | 23 | n = num 24 | return True 25 | -------------------------------------------------------------------------------- /203. 移除链表元素: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | def removeElements(self, head, val): 9 | """ 10 | :type head: ListNode 11 | :type val: int 12 | :rtype: ListNode 13 | """ 14 | """ 15 | 这题就是两个考点： 16 | 1.各种边界条件 17 | head自身为null 18 | head自身需要被删除 19 | 2.遍历链表，删除所有的需要被删除的节点 20 | """ 21 | #1.删除head自身为val的情况 22 | while head and head.val == val: 23 | head = head.next 24 | if not head: 25 | return head 26 | #2.遍历列表，删除节点 27 | cur = head 28 | while cur.next: 29 | if cur.next.val == val: 30 | cur.next = cur.next.next 31 | else: 32 | cur = cur.next 33 | return head 34 | -------------------------------------------------------------------------------- /204. 计数质数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def countPrimes(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | #质数（又称素数），指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数 8 | """ 9 | 具体操作：先将 2~n 的各个数放入表中，然后在2的上面画一个圆圈，然后划去2的其他倍数； 10 | 第一个既未画圈又没有被划去的数是3，将它画圈，再划去3的其他倍数； 11 | 现在既未画圈又没有被划去的第一个数 是5，将它画圈，并划去5的其他倍数……依次类推，一直到所有小于或等于 n 的各数都画了圈或划去为止。 12 | 这时，表中画了圈的以及未划去的那些数正好就是小于 n 的素数。 13 | """ 14 | nums = [] 15 | if n <= 2: 16 | return 0 17 | nums = [x for x in range(2,n)] 18 | for i in nums: 19 | for j in nums: 20 | if j > i and j%i == 0: 21 | nums.remove(j) 22 | return len(nums) 23 | -------------------------------------------------------------------------------- /205. 同构字符串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isIsomorphic(self, s, t): 3 | """ 4 | :type s: str 5 | :type t: str 6 | :rtype: bool 7 | """ 8 | def isoHelper(s1, s2): 9 | lookup = {} 10 | for i, c in enumerate(s1): 11 | if s2[i] in lookup: 12 | if c != lookup[s2[i]]: 13 | return False 14 | else: 15 | lookup[s2[i]] = c 16 | return True 17 | 18 | return isoHelper(s, t) and isoHelper(t, s) 19 | 20 | class Solution(object): 21 | def isIsomorphic(self, s, t): 22 | """ 23 | :type s: str 24 | :type t: str 25 | :rtype: bool 26 | """ 27 | #保证互相映射 28 | def helper(s1,s2): 29 | dic = {} 30 | for i in range(len(s1)): 31 | if s1[i] in dic: 32 | if dic[s1[i]] != s2[i]: 33 | return False 34 | else: 35 | dic[s1[i]] = s2[i] 36 | return True 37 | return helper(s,t) and helper(t,s) 38 | 39 | -------------------------------------------------------------------------------- /206. 反转链表: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | 解题思路（递归法） 8 | 现在需要把A->B->C->D进行反转， 9 | 1. 可以先假设B->C->D已经反转好，已经成为了D->C->B，那么接下来要做的事情就是将D->C->B看成一个整体，让这个整体的next指向A，所以问题转化了反转B->C->D。那么， 10 | 2. 可以先假设C->D已经反转好，已经成为了D->C,那么接下来要做的事情就是将D->C看成一个整体，让这个整体的next指向B，所以问题转化了反转C->D。那么， 11 | 依次类推...... 12 | 13 | 14 | class Solution(object): 15 | def reverseList(self, head): 16 | """ 17 | :type head: ListNode 18 | :rtype: ListNode 19 | """ 20 | #head为None或只有一个head 21 | if head == None or head.next == None: 22 | return head 23 | 24 | #假设head.next已反转好，仅需移动head的位置 25 | new_head = self.reverseList(head.next) 26 | #head之前的next现在排在队尾，将head插入至head.next之后 27 | head.next.next = head 28 | #末尾为NULL 29 | head.next = None 30 | return new_head 31 | 32 | #解法2 33 | # Definition for singly-linked list. 34 | # class ListNode(object): 35 | # def __init__(self, x): 36 | # self.val = x 37 | # self.next = None 38 | 39 | class Solution(object): 40 | def reverseList(self, head): 41 | """ 42 | :type head: ListNode 43 | :rtype: ListNode 44 | """ 45 | #使用栈来实现，先进后出 46 | #注意这里stack中初始元素为None，否则会报错空 47 | stack = [None] 48 | p = head 49 | while p: 50 | stack.append(p) 51 | p = p.next 52 | 53 | head = stack.pop() 54 | p = head 55 | #这里也以none来判断结束 56 | while p: 57 | p.next = stack.pop() 58 | p = p.next 59 | return head 60 | -------------------------------------------------------------------------------- /21. 合并两个有序链表: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution: 8 | def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: 9 | #思想：建立一个新链表将两个列表的元素大小进行比较,依次加入到链表中 10 | #1.建立空列表，从头结点为当前节点 11 | head = ListNode(None) 12 | cur = head 13 | #2.当l1,l2存在时，不断比较链表中元素大小 14 | while l1 or l2: 15 | #3. 当l1或者l2为空的情况，接在空链表后面 16 | if not l1: 17 | cur.next = l2 18 | break 19 | if not l2: 20 | cur.next = l1 21 | break 22 | #如果l1,l2都存在，比较链表中元素，将小元素插在新链表后面 23 | if l1.val < l2.val: 24 | cur.next = l1 25 | #当前节点向后移 26 | cur = cur.next 27 | #l1减少一个节点 28 | l1 = l1.next 29 | else: 30 | cur.next = l2 31 | cur = cur.next 32 | l2 = l2.next 33 | #返回头结点之后的链表啊 34 | return head.next 35 | -------------------------------------------------------------------------------- /217. 存在重复元素: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def containsDuplicate(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: bool 6 | """ 7 | dic = {} 8 | for i in nums: 9 | dic[i] = dic.get(i,0) + 1 10 | if dic[i] == 2: 11 | return True 12 | return False 13 | -------------------------------------------------------------------------------- /219. 存在重复元素 II: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool: 3 | dic = {} 4 | for i in range(len(nums)): 5 | if nums[i] in dic: 6 | if i - dic[nums[i]] <= k: 7 | return True 8 | else: 9 | dic[nums[i]] = i 10 | else: 11 | dic[nums[i]] = i 12 | return False 13 | -------------------------------------------------------------------------------- /226. 翻转二叉树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def invertTree(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: TreeNode 13 | """ 14 | if root == None: 15 | return None 16 | root.left, root.right = root.right, root.left 17 | self.invertTree(root.left) 18 | self.invertTree(root.right) 19 | return root 20 | -------------------------------------------------------------------------------- /231. 2的幂: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPowerOfTwo(self, n): 3 | """ 4 | :type n: int 5 | :rtype: bool 6 | """ 7 | #bin() 返回一个整数 int 或者长整数 long int 的二进制表示。 用法： bin(n) 8 | #list(map()) 接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回 用法：list(map(f,list)) 返回一个通过f函数变换的list 9 | #sum()的参数是一个list 用法：sum([1,2,3]) 10 | 11 | #本题解法：1的二进制表示为0b1，2的二进制表示为0b10，4的二进制表示为0b100，16的二进制表示为0b1000。 当二进制各位之和 == 1时，则该数为2的幂 12 | if n <= 0: 13 | return False 14 | 15 | 16 | b = bin(n)[2:] 17 | list_b = list(map(int,b)) 18 | sum_b = sum(list_b) 19 | 20 | if sum_b == 1: 21 | return True 22 | return False 23 | -------------------------------------------------------------------------------- /234. 回文链表: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | def isPalindrome(self, head): 9 | """ 10 | :type head: ListNode 11 | :rtype: bool 12 | """ 13 | res = [] 14 | #先将链表转化为列表，再判断是否为回文串 15 | while(head): 16 | res.append(head.val) 17 | head = head.next 18 | #注：[]也是回文串 19 | new = res[::-1] 20 | return new == res 21 | -------------------------------------------------------------------------------- /235. 二叉搜索树的最近公共祖先: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def lowestCommonAncestor(self, root, p, q): 10 | """ 11 | :type root: TreeNode 12 | :type p: TreeNode 13 | :type q: TreeNode 14 | :rtype: TreeNode 15 | 利用二叉搜索树的特性，可以通过比较所找节点与根节点的大小确认其所在的子树，若两节点都在左子树或右子 树，则递归搜索，若一边一个，则返回根节点。 16 | """ 17 | #对二叉搜索树利用递归算法 18 | #都在左子树，则在左子树查找 19 | if p.val < root.val and q.val < root.val: 20 | return self.lowestCommonAncestor(root.left, p, q) 21 | ##都在右子树，则在右子树查找 22 | elif p.val > root.val and q.val > root.val: 23 | return self.lowestCommonAncestor(root.right, p, q) 24 | elif p.val <= root.val <= q.val or q.val <= root.val <= p.val: 25 | return root 26 | -------------------------------------------------------------------------------- /237. 删除链表中的节点: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | 7 | class Solution(object): 8 | #这里的node就指向一个链表节点 9 | def deleteNode(self, node): 10 | """ 11 | :type node: ListNode 12 | :rtype: void Do not return anything, modify node in-place instead. 13 | """ 14 | #将下一个节点的值给node，node指向nxt.next 15 | nxt = node.next 16 | node.val = nxt.val 17 | node.next = nxt.next 18 | -------------------------------------------------------------------------------- /242. 有效的字母异位词: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isAnagram(self, s, t): 3 | """ 4 | :type s: str 5 | :type t: str 6 | :rtype: bool 7 | """ 8 | #str.replace(old, new[, max]) max：用来替换的次数 9 | #当我们将max参数传入后，则将旧字符串替换为新字符串不超过max次，多余的则不进行替换 10 | if len(s) != len(t): 11 | return False 12 | for i in s: 13 | if i in t: 14 | t = t.replace(i,'',1) #这里注意：将替换后的值赋值给t 15 | if t == '': 16 | return True 17 | else: 18 | return False 19 | -------------------------------------------------------------------------------- /257. 二叉树的所有路径: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def binaryTreePaths(self, root: TreeNode) -> List[str]: 3 | #常规方法递归法 4 | """ 5 | #在递归遍历二叉树时，需要考虑当前的节点和它的孩子节点。 6 | 1.如果当前的节点不是叶子节点，则在当前的路径末尾添加该节点，并递归遍历该节点的每一个孩子节点。 7 | 2.如果当前的节点是叶子节点，则在当前的路径末尾添加该节点后，就得到了一条从根节点到叶子节点的路径，可以把该路径加入到答案中。 8 | 9 | """ 10 | paths = [] 11 | def construct_paths(root,path): 12 | if root: 13 | path += str(root.val) 14 | if not root.left and not root.right: 15 | paths.append(path) 16 | else: 17 | path += '->' 18 | construct_paths(root.left,path) 19 | construct_paths(root.right,path) 20 | return paths 21 | paths = construct_paths(root,'') 22 | return paths 23 | -------------------------------------------------------------------------------- /258. 各位相加: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def addDigits(self, num): 3 | """ 4 | :type num: int 5 | :rtype: int 6 | """ 7 | #递归法 8 | if num <= 9: 9 | return num 10 | else: 11 | count = 0 12 | num = str(num) 13 | for i in num: 14 | count += int(i) 15 | num = count 16 | return self.addDigits(num) 17 | -------------------------------------------------------------------------------- /26. 删除排序数组中的重复项: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeDuplicates(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | cur = 0 8 | #如果当前位置数值与上一个不同，则放在当前位置后面 9 | for i in range(1, len(nums)): 10 | if nums[cur] != nums[i]: 11 | nums[cur+1] = nums[i] 12 | cur += 1 13 | return cur+1 14 | -------------------------------------------------------------------------------- /263. 丑数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isUgly(self, num): 3 | """ 4 | :type num: int 5 | :rtype: bool 6 | """ 7 | #不停地除去2 3 5，直到不能整除，最后的数如果是1，则是丑数，如果不是1，则不是丑数 8 | def divide(x,d): 9 | while x % d == 0: 10 | x = x/d 11 | return x 12 | 13 | num = divide(num,2) 14 | num = divide(num,3) 15 | num = divide(num,5) 16 | 17 | if num == 1: 18 | return True 19 | else: 20 | return False 21 | -------------------------------------------------------------------------------- /268. 缺失数字: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def missingNumber(self, nums: List[int]) -> int: 3 | sum_all = 0 4 | for i in range(len(nums)+1): 5 | sum_all += i 6 | sum_num = sum(nums) 7 | return sum_all - sum_num 8 | -------------------------------------------------------------------------------- /27. 移除元素: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def removeElement(self, nums, val): 3 | """ 4 | :type nums: List[int] 5 | :type val: int 6 | :rtype: int 7 | """ 8 | #列表倒置 9 | for i in reversed(nums): 10 | if i == val: 11 | nums.remove(i) 12 | return len(nums) 13 | -------------------------------------------------------------------------------- /278. 第一个错误的版本: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def firstBadVersion(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | #二分查找算法 8 | #注：isBadVersion为True,代表有bug 9 | left = 0 10 | right = n 11 | mid =(left + right) //2 12 | while left < right: 13 | if not isBadVersion(mid): 14 | left = mid + 1 15 | if isBadVersion(mid): 16 | right = mid 17 | mid = (left + right)//2 18 | return mid 19 | -------------------------------------------------------------------------------- /28. 实现strStr(): -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def strStr(self, haystack, needle): 3 | """ 4 | :type haystack: str 5 | :type needle: str 6 | :rtype: int 7 | """ 8 | if not needle: 9 | return 0 10 | if needle not in haystack: 11 | return -1 12 | for i in range(len(haystack)): 13 | if haystack[i] == needle[0]: 14 | if haystack[i:i+len(needle)] == needle: 15 | return i 16 | -------------------------------------------------------------------------------- /283. 移动零: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def moveZeroes(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: None Do not return anything, modify nums in-place instead. 6 | """ 7 | #必须在原数组上操作，不能拷贝额外的数组。 8 | if len(nums) == 0: 9 | return None 10 | count = 0 11 | for i in range(len(nums)): 12 | if nums[i] != 0: 13 | nums[count] = nums[i] 14 | count = count + 1 15 | for i in range(count,len(nums)): 16 | nums[i] = 0 17 | -------------------------------------------------------------------------------- /290. 单词规律: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def wordPattern(self, pattern, str): 3 | """ 4 | :type pattern: str 5 | :type str: str 6 | :rtype: bool 7 | """ 8 | #与之前的一道题目解法相近，但要注意到：保证唯一性及双向映射，需要两个字典 9 | dic_1 = {} 10 | dic_2 = {} 11 | str_split = str.split(" ") 12 | #先判断长度是否相等 13 | if len(pattern) != len(str_split): 14 | return False 15 | for i in range(len(pattern)): 16 | if pattern[i] not in dic_1 and str_split[i] not in dic_2: 17 | dic_1[pattern[i]] = str_split[i] 18 | dic_2[str_split[i]] = pattern[i] 19 | elif pattern[i] in dic_1: 20 | if dic_1[pattern[i]] != str_split[i]: 21 | return False 22 | elif str_split[i] in dic_2: 23 | if dic_2[str_split[i]] != pattern[i]: 24 | return False 25 | return True 26 | -------------------------------------------------------------------------------- /292. Nim 游戏: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def canWinNim(self, n): 3 | """ 4 | :type n: int 5 | :rtype: bool 6 | """ 7 | #脑筋急转弯，如果堆中有 4 块石头，那么你永远不会赢得比赛 8 | #只要轮到你的时候剩余石头数量不是 4 的倍数你都是完胜，因为你有办法使得每次轮到对方的时候剩余石头数量都为 4 的倍数；如果石头数量是4的倍数，你就会输。 9 | if n%4 == 0: 10 | return False 11 | return True 12 | -------------------------------------------------------------------------------- /3. 无重复字符的最长子串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def lengthOfLongestSubstring(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | temp = '' #空串 8 | length = 0 9 | max_len = 0 10 | 11 | for i in s: 12 | if i not in temp: 13 | temp += i 14 | length += 1 15 | else: 16 | index = temp.index(i) 17 | temp = temp[index+1:] #保留重复i之后的字符 18 | temp = temp + i # 新匹配串（加上i） 19 | 20 | #更新不重复字符最大长度 21 | if length > max_len: 22 | max_len = length 23 | length = len(temp) #新len 24 | #比较最后一次遍历中，length与num_len 25 | if length > max_len: 26 | max_len = length 27 | return max_len 28 | -------------------------------------------------------------------------------- /303. 区域和检索 - 数组不可变: -------------------------------------------------------------------------------- 1 | class NumArray(object): 2 | 3 | def __init__(self, nums): 4 | """ 5 | :type nums: List[int] 6 | """ 7 | self.nums = nums 8 | 9 | def sumRange(self, i, j): 10 | """ 11 | :type i: int 12 | :type j: int 13 | :rtype: int 14 | """ 15 | if j+1 == len(self.nums): 16 | res = sum(self.nums[i:]) 17 | else: 18 | res = sum(self.nums[i:j+1]) 19 | 20 | return res 21 | # Your NumArray object will be instantiated and called as such: 22 | # obj = NumArray(nums) 23 | # param_1 = obj.sumRange(i,j) 24 | -------------------------------------------------------------------------------- /326. 3的幂: -------------------------------------------------------------------------------- 1 | 刷累了，还是用循环解题吧 2 | class Solution: 3 | def isPowerOfThree(self, n: int) -> bool: 4 | #还是用循环解题吧 5 | #忘记考虑3**0 = 1的情况 6 | if n == 0: 7 | return False 8 | if n == 1: 9 | return True 10 | while n >= 3: 11 | if n == 3: 12 | return True 13 | n = n/3 14 | return False 15 | -------------------------------------------------------------------------------- /342. 4的幂: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPowerOfFour(self, num): 3 | """ 4 | :type num: int 5 | :rtype: bool 6 | """ 7 | #递归法 8 | if num <= 0: 9 | return False 10 | if num == 1: 11 | return True 12 | if num % 4 == 0: 13 | num = num // 4 14 | return self.isPowerOfFour(num) 15 | -------------------------------------------------------------------------------- /344. 反转字符串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def reverseString(self, s): 3 | """ 4 | :type s: List[str] 5 | :rtype: None Do not return anything, modify s in-place instead. 6 | """ 7 | #你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题 8 | s[:] = s[::-1] 9 | -------------------------------------------------------------------------------- /345. 反转字符串中的元音字母: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def reverseVowels(self, s): 3 | """ 4 | :type s: str 5 | :rtype: str 6 | """ 7 | #元音字母为 'A、E、I、O、U', 注意题目里没有提示是否包含大小写字母 8 | #两个指针，一个从前往后扫，一个从后往前扫。 9 | vowel = {'A', 'E','I','O','U','a', 'e','i','o','u'} 10 | i, j = 0, len(s) - 1 11 | s = list(s) 12 | while i < j: 13 | if s[i] in vowel and s[j] in vowel: 14 | s[i], s[j] = s[j], s[i] 15 | i = i + 1 16 | j = j - 1 17 | if s[i] not in vowel: 18 | i = i + 1 19 | if s[j] not in vowel: 20 | j = j - 1 21 | res = ''.join(s) 22 | return res 23 | -------------------------------------------------------------------------------- /349. 两个数组的交集: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def intersection(self, nums1, nums2): 3 | """ 4 | :type nums1: List[int] 5 | :type nums2: List[int] 6 | :rtype: List[int] 7 | """ 8 | #应用python的set函数去重 9 | nums1 = set(nums1) 10 | nums2 = set(nums2) 11 | inter = nums1 & nums2 #求集合交集 12 | #集合转换为list 13 | return list(inter) 14 | -------------------------------------------------------------------------------- /35. 搜索插入位置: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def searchInsert(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: int 7 | """ 8 | #nums是排序数组，只需要从左到右比较大小即可 9 | for i in range(len(nums)): 10 | if nums[i] >= target: 11 | return i 12 | #否则插入列表最后面 13 | return len(nums) 14 | 15 | 16 | #二分法 17 | class Solution(object): 18 | def searchInsert(self, nums, target): 19 | """ 20 | :type nums: List[int] 21 | :type target: int 22 | :rtype: int 23 | """ 24 | #排序数组->二分法 25 | l = 0 26 | r = len(nums) - 1 27 | while(l<=r): 28 | mid = (l+r)//2 29 | if nums[mid] == target: 30 | return mid 31 | if nums[mid] > target: 32 | r = mid - 1 33 | if nums[mid] < target: 34 | l = mid + 1 35 | #输出左边界 36 | return l 37 | -------------------------------------------------------------------------------- /350. 两个数组的交集 II: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def intersect(self, nums1, nums2): 3 | """ 4 | :type nums1: List[int] 5 | :type nums2: List[int] 6 | :rtype: List[int] 7 | """ 8 | #注：输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。 9 | insert = [] 10 | for i in nums1: 11 | if i in nums2: 12 | insert.append(i) 13 | nums2.remove(i) 14 | return insert 15 | -------------------------------------------------------------------------------- /367. 有效的完全平方数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPerfectSquare(self, num): 3 | """ 4 | :type num: int 5 | :rtype: bool 6 | """ 7 | #二分查找法，若存在num == mid*mid，0 num: 18 | r = mid #左开右闭 19 | mid = (l + r)/2 20 | return num == mid*mid 21 | -------------------------------------------------------------------------------- /371. 两整数之和: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def getSum(self, a, b): 3 | """ 4 | :type a: int 5 | :type b: int 6 | :rtype: int 7 | """ 8 | #偷个懒 9 | return sum([a,b]) 10 | -------------------------------------------------------------------------------- /374. 猜数字大小: -------------------------------------------------------------------------------- 1 | # The guess API is already defined for you. 2 | # @param num, your guess 3 | # @return -1 if my number is lower, 1 if my number is higher, otherwise return 0 4 | # def guess(num): 5 | 6 | class Solution(object): 7 | def guessNumber(self, n): 8 | """ 9 | :type n: int 10 | :rtype: int 11 | """ 12 | #二分法 13 | l, r = 0, n 14 | mid = (l+r)//2 15 | while l < r: 16 | if guess(mid) == 0: 17 | return mid 18 | elif guess(mid) == -1: 19 | r = mid #注意：左开右闭 20 | elif guess(mid) == 1: 21 | l = mid + 1 22 | mid = (l + r)//2 23 | return mid #这里注意，在0`n中一定存在mid，这里区别于普通的二分法查找 24 | -------------------------------------------------------------------------------- /383. 赎金信: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def canConstruct(self, ransomNote, magazine): 3 | """ 4 | :type ransomNote: str 5 | :type magazine: str 6 | :rtype: bool 7 | """ 8 | #用空串替换magazine中相同的字符，再判断串的长度 9 | for s in ransomNote: 10 | new_magazine = magazine.replace(s,"",1) 11 | #如果不能替换，返回false 12 | if len(new_magazine) == len(magazine): 13 | return False 14 | magazine = new_magazine #替换后的为新的magazine字符串 15 | 16 | return True 17 | -------------------------------------------------------------------------------- /387. 字符串中的第一个唯一字符: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def firstUniqChar(self, s: str) -> int: 3 | #如果不存在，则返回 -1 4 | str_dict = {} 5 | for i in s: 6 | str_dict[i] = str_dict.get(i,0) + 1 7 | for j in range(len(s)): 8 | if str_dict[s[j]] == 1: 9 | return j 10 | 11 | return -1 12 | -------------------------------------------------------------------------------- /389. 找不同: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findTheDifference(self, s, t): 3 | """ 4 | :type s: str 5 | :type t: str 6 | :rtype: str 7 | """ 8 | for i in s: 9 | t = t.replace(i,'',1) 10 | return t 11 | -------------------------------------------------------------------------------- /404. 左叶子之和: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def sumOfLeftLeaves(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: int 13 | """ 14 | #递归法 15 | if not root: 16 | return 0 17 | if root.left and not root.left.left and not root.left.right: 18 | return root.left.val + self.sumOfLeftLeaves(root.right) 19 | else: 20 | return self.sumOfLeftLeaves(root.left) + self.sumOfLeftLeaves(root.right) 21 | -------------------------------------------------------------------------------- /409. 最长回文串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def longestPalindrome(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | """ 8 | 解题思路： 9 | 10 | 1. 找出字符串中每个字符出现的次数 11 | 2. 若字符出现次数为奇数次，出现的次数减去1则为可用于构造回文串的字符数。若出现的次数为偶数次，出现次数则为可用于构造回文串的字符数 12 | 3. 若存在奇数次字符，则最终结果再＋1，因为奇数字符可放一个在最中间。 13 | 14 | """ 15 | #统计每个字符出现的次数 16 | res = 0 17 | dic = {} 18 | for i in s: 19 | dic[i] = dic.get(i,0) + 1 20 | 21 | 22 | exist_odd = False #判断是否存在奇数 23 | for k in dic: 24 | if dic[k]%2 == 0: 25 | res += dic[k] 26 | else: 27 | res += (dic[k]-1) 28 | exist_odd = True 29 | 30 | if exist_odd == True: 31 | res += 1 32 | return res 33 | -------------------------------------------------------------------------------- /412. Fizz Buzz: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def fizzBuzz(self, n): 3 | """ 4 | :type n: int 5 | :rtype: List[str] 6 | """ 7 | res = [] 8 | for i in range(1,n+1): 9 | if i % 3 == 0 and i % 5 == 0: 10 | res.append("FizzBuzz") 11 | elif i % 3 == 0: 12 | res.append("Fizz") 13 | elif i % 5 == 0: 14 | res.append("Buzz") 15 | else: 16 | res.append(str(i)) 17 | return res 18 | -------------------------------------------------------------------------------- /414. 第三大的数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def thirdMax(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | #去重 8 | nums = list(set(nums)) 9 | if len(nums) < 3: 10 | return max(nums) 11 | 12 | 13 | max1 = max(nums) 14 | 15 | #删去第一大 16 | for num in nums: 17 | if num == max1: 18 | nums.remove(num) 19 | 20 | if len(nums) == 0: 21 | return max1 22 | 23 | #删去第二大 24 | max2 = max(nums) 25 | for num in nums: 26 | if num == max2: 27 | nums.remove(num) 28 | 29 | if len(nums) == 0: 30 | return max2 31 | 32 | max3 = max(nums) 33 | 34 | 35 | return max3 36 | -------------------------------------------------------------------------------- /429. N叉树的层序遍历: -------------------------------------------------------------------------------- 1 | from collections import deque 2 | """ 3 | # Definition for a Node. 4 | class Node: 5 | def __init__(self, val, children): 6 | self.val = val 7 | self.children = children 8 | """ 9 | #append与extend的区别：append(object) 是将一个对象作为一个整体添加到列表中，extend(iterable) 是将一个可迭代对象中的每个元素逐个地添加到列表中 10 | #deque([]) deque模块是python标准库collections中的一项 双端队列 入队：deque.append() 出队：deque.popleft() 从列表左边弹出 11 | class Solution: 12 | def levelOrder(self, root: 'Node') -> List[List[int]]: 13 | res = [] 14 | if not root: 15 | return res 16 | dq = deque([root]) #deuqe双端队列的用法 17 | level = 0 18 | while dq: 19 | res.append([]) 20 | for _ in range(len(dq)): 21 | cur = dq.popleft() 22 | res[level].append(cur.val) 23 | dq.extend(cur.children) 24 | 25 | level += 1 26 | return res 27 | 28 | #更好的方法 29 | """ 30 | # Definition for a Node. 31 | class Node(object): 32 | def __init__(self, val, children): 33 | self.val = val 34 | self.children = children 35 | """ 36 | class Solution(object): 37 | def levelOrder(self, root): 38 | """ 39 | :type root: Node 40 | :rtype: List[List[int]] 41 | """ 42 | if not root: 43 | return 44 | res = [] 45 | cur_level = [root] #存放当前层的node 46 | while cur_level: 47 | temp = [] #存放当前层的val 48 | next_level = [] #存放下一层的node 49 | for i in cur_level: 50 | temp.append(i.val) 51 | if i.children: 52 | for j in i.children: 53 | next_level.append(j) 54 | res.append(temp) 55 | cur_level = next_level 56 | return res 57 | -------------------------------------------------------------------------------- /434. 字符串中的单词数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def countSegments(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | if len(s) == 0: 8 | return 0 9 | return len(s.split( )) 10 | -------------------------------------------------------------------------------- /437. 路径总和 III: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | 9 | #双重递归 思路：首先先序递归遍历每个节点，再以每个节点作为起始点递归寻找满足条件的路径。 10 | class Solution(object): 11 | def pathSum(self, root, sum): 12 | """ 13 | :type root: TreeNode 14 | :type sum: int 15 | :rtype: int 16 | """ 17 | if not root: 18 | return 0 19 | def dfs(root, sum): 20 | count = 0 #记录路径个数 21 | if not root: 22 | return 0 23 | if root.val == sum: 24 | count += 1 25 | count += dfs(root.left, sum - root.val) 26 | count += dfs(root.right, sum - root.val) 27 | return count 28 | return dfs(root, sum) + self.pathSum(root.left, sum) + self.pathSum(root.right, sum) 29 | -------------------------------------------------------------------------------- /441. 排列硬币: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def arrangeCoins(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | 8 | if n == 0: 9 | return 0 10 | 11 | k = 1 12 | while n >= k: 13 | n = n - k 14 | k += 1 15 | return k - 1 16 | -------------------------------------------------------------------------------- /448. 找到所有数组中消失的数字: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findDisappearedNumbers(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: List[int] 6 | """ 7 | # 因为每个元素的值 v 都小于等于 数组元素长度n 8 | # 所以可以用读取到的元素值 v，去寻找对应的下标 j = v-1 9 | # 如果 nums[j] 被 访问过，则标为负数 10 | for num in nums: 11 | i = abs(num) - 1 #注意：这里一定要加abs，因为在遍历过程中，nums也在改变，出现了负数 12 | nums[i] = -abs(nums[i]) 13 | print(nums) 14 | # 剩下的为正的元素的下标，则未访问过， 15 | # 代表下标 i 对应的值 i+1 为未出现过的元素 16 | res = [k + 1 for k, v in enumerate(nums) if v > 0] 17 | return res 18 | -------------------------------------------------------------------------------- /455. 分发饼干: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findContentChildren(self, g, s): 3 | """ 4 | :type g: List[int] 5 | :type s: List[int] 6 | :rtype: int 7 | """ 8 | #排序函数list.sort(cmp=None, key=None, reverse=False) 默认升序， reverse=False时为升序 9 | #一个小朋友最多只能拥有一块饼干。 10 | g.sort() 11 | s.sort() 12 | 13 | len_g = len(g) 14 | len_s = len(s) 15 | 16 | res = 0 17 | i = 1 18 | j = 1 19 | while i <= len_g and j <= len(s): 20 | #如果满足胃口 21 | if g[i-1] <= s[j-1]: 22 | res += 1 23 | i += 1 24 | j += 1 25 | #如果不满足胃口 26 | else: 27 | j += 1 28 | 29 | return res 30 | -------------------------------------------------------------------------------- /459. 重复的子字符串: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def repeatedSubstringPattern(self, s): 3 | """ 4 | :type s: str 5 | :rtype: bool 6 | """ 7 | """ 8 | 1.一个字符串如果符合要求，则该字符串至少由2个子串组成。例：b b / abc abc 9 | 10 | 2.s+s以后，则该字符串至少由4个子串组成 bb+bb / abcabc+abcabc 11 | 12 | 3.截去首尾各一个字符s[1:-1] （注：只截一个是为了判断类似本例，重复子串长度为1的情况。当重复子串长度大于1时，任意截去首尾小于等于重复子字符串长度都可） 13 | 14 | 4.由于s+s组成的4个重复子串被破坏了首尾2个，则只剩下中间两个 bc abcabc ab。此时在判断中间两个子串组成是否等于s，若是，则成立。 15 | 16 | """ 17 | str1 = (s+s)[1:-1] 18 | return s in str1 19 | -------------------------------------------------------------------------------- /461. 汉明距离: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def hammingDistance(self, x, y): 3 | """ 4 | :type x: int 5 | :type y: int 6 | :rtype: int 7 | """ 8 | #str.count(sub, start= 0,end=len(string)) 统计字符串里某个字符出现的次数 9 | #先异或（相异为1），再统计1的个数（即不相同的个数） 10 | res = bin(x^y).count('1') 11 | return res 12 | -------------------------------------------------------------------------------- /476. 数字的补数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def findComplement(self, num): 3 | """ 4 | :type num: int 5 | :rtype: int 6 | """ 7 | #找到一个二进制位数与num相同但每一位都为1的数，然后用这个数 减去 num / 用这个数和num异或 8 | length = len(bin(num)) - 2 9 | a = (1<=0 and kmax_len): 16 | max_len = k-j+1 17 | start = j 18 | j = j-1 19 | k = k+1 20 | 21 | #子串为偶数 22 | for i in range(len(s)): 23 | j = i 24 | k = i+1 25 | while(j>=0 and kmax_len): 27 | max_len = k-j+1 28 | start = j 29 | j = j-1 30 | k = k+1 31 | return s[start:start+max_len] 32 | -------------------------------------------------------------------------------- /509. 斐波那契数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def fib(self, N): 3 | """ 4 | :type N: int 5 | :rtype: int 6 | """ 7 | #动态规划 8 | dic = {} 9 | dic[0] = 0 10 | dic[1] = 1 11 | if N <= 1: 12 | return dic[N] 13 | for i in range(2,N+1): 14 | dic[i] = dic[i-2] + dic[i-1] 15 | 16 | return dic[N] 17 | -------------------------------------------------------------------------------- /53. 最大子序和: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def maxSubArray(self, nums): 3 | """ 4 | :type nums: List[int] 5 | :rtype: int 6 | """ 7 | sum = 0 8 | max_result = nums[0] 9 | for i in range(len(nums)): 10 | sum += nums[i] 11 | if sum > max_result: 12 | max_result = sum 13 | if sum < 0: 14 | sum = 0 15 | return max_result 16 | -------------------------------------------------------------------------------- /543. 二叉树的直径: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | 9 | #当前节点的直径就是左右子节点的深度之和，最大直径就是所有节点左右节点的深度之和 10 | class Solution(object): 11 | def __init__(self): 12 | self.ans = 0 13 | 14 | 15 | 16 | def diameterOfBinaryTree(self, root): 17 | """ 18 | :type root: TreeNode 19 | :rtype: int 20 | """ 21 | if not root: 22 | return 0 23 | self.depth(root) 24 | return self.ans 25 | 26 | 27 | 28 | def depth(self, root): 29 | if not root: 30 | return 0 31 | left = self.depth(root.left) 32 | right = self.depth(root.right) 33 | 34 | if left + right > self.ans: 35 | self.ans = left + right 36 | 37 | 38 | return 1+max(left,right) 39 | -------------------------------------------------------------------------------- /557. 反转字符串中的单词 III: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def reverseWords(self, s): 3 | """ 4 | :type s: str 5 | :rtype: str 6 | """ 7 | 8 | #Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。 用法： str.join(sequence) str为指定字符 9 | list_s = [] 10 | words = s.split(' ') 11 | for word in words: 12 | word_rev = word[::-1] 13 | list_s.append(word_rev) 14 | new_s = " ".join(list_s) 15 | return new_s 16 | -------------------------------------------------------------------------------- /58. 最后一个单词的长度: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def lengthOfLastWord(self, s): 3 | """ 4 | :type s: str 5 | :rtype: int 6 | """ 7 | s = s.strip(' ') 8 | if len(s) == 0: 9 | return 0 10 | last_word = s.split(' ')[-1] 11 | return len(last_word) 12 | -------------------------------------------------------------------------------- /617. 合并二叉树: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def mergeTrees(self, t1, t2): 10 | """ 11 | :type t1: TreeNode 12 | :type t2: TreeNode 13 | :rtype: TreeNode 14 | """ 15 | if not t1 and not t2: 16 | return 17 | root = TreeNode(0) #建立一个空节点 18 | if t1 and not t2: 19 | root = t1 20 | elif not t1 and t2: 21 | root = t2 22 | else: 23 | root.val = t1.val + t2.val 24 | root.left = self.mergeTrees(t1.left, t2.left) 25 | root.right = self.mergeTrees(t1.right, t2.right) 26 | 27 | return root 28 | -------------------------------------------------------------------------------- /66. 加一: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def plusOne(self, digits): 3 | """ 4 | :type digits: List[int] 5 | :rtype: List[int] 6 | """ 7 | #注意：为9的情况，在首位插入1 8 | #倒序遍历 9 | for i in range(len(digits)-1,-1,-1): 10 | if digits[i] == 9: 11 | digits[i] = 0 12 | #数组中只有一个数字为9的情况，先置0，再在首位插入1 13 | if i == 0: 14 | digits.insert(0,1) 15 | else: 16 | #当不进位，直接加1 17 | #当进位时，再第二次循环到前一个数字+1 18 | digits[i] += 1 19 | break 20 | return digits 21 | -------------------------------------------------------------------------------- /67. 二进制求和: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def addBinary(self, a, b): 3 | """ 4 | :type a: str 5 | :type b: str 6 | :rtype: str 7 | """ 8 | a = int(a,2) 9 | b = int(b,2) 10 | return bin(a+b)[2:] 11 | -------------------------------------------------------------------------------- /69. x 的平方根: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def mySqrt(self, x): 3 | """ 4 | :type x: int 5 | :rtype: int 6 | """ 7 | #牛顿迭代法求平方根的公式 r = (r + x // r) // 2 8 | #初始r = x, 直到 r*r <= x停止 9 | r = x 10 | while r*r > x: 11 | r = (r + x // r)//2 12 | return r 13 | 14 | class Solution(object): 15 | def mySqrt(self, x): 16 | """ 17 | :type x: int 18 | :rtype: int 19 | """ 20 | #二分法 一个数的平方根不超过本身 21 | if x <= 1: 22 | return x 23 | 24 | l = 0 25 | r = x 26 | while (l x: 31 | r = mid-1 32 | if mid*mid < x: 33 | l = mid 34 | 35 | return l 36 | -------------------------------------------------------------------------------- /7. 整数反转: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverse(self, x: int) -> int: 3 | str_x = str(x) 4 | str_new = '' 5 | if str_x[0] == '-': 6 | str_new += '-' 7 | str_x = str_x.lstrip('-') 8 | str_rev = str_x[: :-1] 9 | str_new += str_rev 10 | else: 11 | str_new = str_x[ : :-1] 12 | 13 | if str_new[0] == '-': 14 | x_new = -int(str_new[1:]) 15 | else: 16 | x_new = int(str_new) 17 | 18 | if (-2**31 < x_new < 2**31): 19 | return x_new 20 | else: 21 | return 0 22 | -------------------------------------------------------------------------------- /70. 爬楼梯: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def climbStairs(self, n): 3 | """ 4 | :type n: int 5 | :rtype: int 6 | """ 7 | #动态规划法：第i阶台阶 = 第i-1阶台阶方法数 + 第i-2阶台阶方法数 8 | #设dp[i] = dp[i-1] + dp[i-2] i为台阶数，dp为方案数 9 | dp = {} 10 | dp[1] = 1 11 | dp[2] = 2 12 | #从i = 3开始计算 13 | for i in range(3,n+1): 14 | dp[i] = dp[i-1] + dp[i-2] 15 | return dp[n] 16 | -------------------------------------------------------------------------------- /704. 二分查找: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def search(self, nums, target): 3 | """ 4 | :type nums: List[int] 5 | :type target: int 6 | :rtype: int 7 | """ 8 | #注：很简单的题目，根本不需要递归 9 | left = 0 10 | right = len(nums) - 1 11 | while(left<=right): 12 | mid = (left+right)//2 13 | if target == nums[mid]: 14 | return mid 15 | elif target < nums[mid]: 16 | right = mid - 1 17 | else: 18 | left = mid + 1 19 | 20 | return -1 21 | -------------------------------------------------------------------------------- /8. 字符串转换整数 (atoi): -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def myAtoi(self, str): 3 | """ 4 | :type str: str 5 | :rtype: int 6 | """ 7 | x = '' 8 | 9 | 10 | #删去前后空格 11 | str = str.strip() 12 | 13 | if str == '': 14 | return 0 15 | 16 | length = len(str) 17 | 18 | #判断首位为正负符号，紧接着数字 19 | 20 | 21 | 22 | if str[0] in {'+','-'}: 23 | if len(str) == 1: 24 | return 0 25 | elif str[1] >= '0' and str[1] <= '9': 26 | x += str[0] 27 | else: 28 | return 0 29 | #首位为数字 30 | elif str[0] >= '0' and str[0] <= '9': 31 | x += str[0] 32 | else: 33 | return 0 34 | 35 | #从第二位开始遍历 36 | for i in range(1,length): 37 | if str[i] >= '0' and str[i] <= '9': 38 | x += str[i] 39 | else: 40 | break 41 | 42 | x = int(x) 43 | 44 | if x <= -2147483648: 45 | return -2147483648 46 | elif x >= 2147483647: 47 | return 2147483647 48 | else: 49 | return x 50 | -------------------------------------------------------------------------------- /83. 删除排序链表中的重复元素: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.next = None 6 | class Solution(object): 7 | def deleteDuplicates(self, head): 8 | """ 9 | :type head: ListNode 10 | :rtype: ListNode 11 | """ 12 | #cur为当前位置指针，指向链表头结点 13 | cur = head 14 | while cur and cur.next: 15 | if cur.val == cur.next.val: 16 | cur.next = cur.next.next 17 | else: 18 | cur = cur.next 19 | return head 20 | -------------------------------------------------------------------------------- /88. 合并两个有序数组: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def merge(self, nums1, m, nums2, n): 3 | #注意：P一定要放在第一行，后面m,n的值改变了！！！ 4 | p = m+n-1 5 | m = m-1 6 | n = n-1 7 | #从每个数组最后一个位置开始比较 8 | while(m>=0 and n>=0): 9 | if nums1[m] > nums2[n]: 10 | nums1[p] = nums1[m] 11 | p = p-1 12 | m = m-1 13 | else: 14 | nums1[p] = nums2[n] 15 | p = p-1 16 | n = n-1 17 | #若n未遍历结束，将其插入nums1中 18 | while n>=0: 19 | nums1[p] = nums2[n] 20 | p = p-1 21 | n = n-1 22 | return None 23 | -------------------------------------------------------------------------------- /9. 回文数: -------------------------------------------------------------------------------- 1 | class Solution(object): 2 | def isPalindrome(self, x): 3 | """ 4 | :type x: int 5 | :rtype: bool 6 | """ 7 | if x < 0 or (x%10 == 0 and x != 0): 8 | return False 9 | 10 | rev = 0 11 | while x > rev: 12 | rev = 10*rev + x%10 13 | x = x//10 14 | 15 | if x == rev or rev//10 == x: 16 | return True 17 | else: 18 | return False 19 | 20 | -------------------------------------------------------------------------------- /94. 二叉树的中序遍历: -------------------------------------------------------------------------------- 1 | # Definition for a binary tree node. 2 | # class TreeNode(object): 3 | # def __init__(self, x): 4 | # self.val = x 5 | # self.left = None 6 | # self.right = None 7 | 8 | class Solution(object): 9 | def inorderTraversal(self, root): 10 | """ 11 | :type root: TreeNode 12 | :rtype: List[int] 13 | """ 14 | res = [] 15 | def helper(node): 16 | if not node: 17 | return 18 | helper(node.left) 19 | res.append(node.val) 20 | helper(node.right) 21 | helper(root) 22 | return res 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Leetcode -------------------------------------------------------------------------------- /二维数组中的查找: -------------------------------------------------------------------------------- 1 | # -*- coding:utf-8 -*- 2 | #/* 思路 3 | #* 矩阵是有序的，从左下角来看，向上数字递减，向右数字递增， 4 | #* 因此从左下角开始查找，当要查找数字比左下角数字大时。右移 5 | #* 要查找数字比左下角数字小时，上移 6 | #*/ 7 | class Solution: 8 | # array 二维列表 9 | def Find(self, target, array): 10 | # write code here 11 | h = len(array) #行数 12 | l = len(array[0]) #列数 13 | i = h - 1 14 | j = 0 15 | while i >=0 and j <= l-1: 16 | if array[i][j] == target: 17 | return True 18 | elif array[i][j] > target: 19 | i -= 1 20 | elif array[i][j] < target: 21 | j += 1 22 | return False 23 | -------------------------------------------------------------------------------- /冒泡排序: -------------------------------------------------------------------------------- 1 | #一句话,让大的数沉底 2 | #两两比较,让大的数放在数组末端 3 | def bubbleSort(nums): 4 | n = len(nums) 5 | f = n 6 | for _ in range(n-1): 7 | for i in range(f-1): 8 | if nums[i] > nums[i+1]: 9 | nums[i],nums[i+1] = nums[i+1],nums[i] 10 | f -= 1 11 | return nums 12 | 13 | nums = [1,4,2,6,4,9,2,5] 14 | print(insertions_sort(nums)) 15 | -------------------------------------------------------------------------------- /利用堆获得 top K: -------------------------------------------------------------------------------- 1 | 问题描述：有N(N>>10000)个整数,求出其中的前K个最大的数。（称作Top k或者Top 10） 2 | 3 | 问题分析： 4 | 5 | 1.对前k个元素建立最小堆 6 | 2.若堆顶元素 b[0]: 48 | temp = nums[i] 49 | nums[i] = b[0] 50 | b[0] = temp 51 | b = heap_adjust(b,0,3) 52 | print(b[0]) 53 | -------------------------------------------------------------------------------- /剑指-用两个栈实现队列: -------------------------------------------------------------------------------- 1 | 题目描述 2 | 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 3 | 4 | # -*- coding:utf-8 -*- 5 | class Solution: 6 | #定义一个栈作为压入栈，在压入数据时，只往这个栈压入； 7 | #另一个栈只为弹出栈，只从这个栈弹出数据 8 | def __init__(self): 9 | self.stackpush = [] 10 | self.stackpop = [] 11 | def push(self, node): 12 | self.stackpush.append(node) 13 | def pop(self): 14 | #要实现队列的先进先出，也就是1.先把数据压入压入栈，2.再把压入栈中的数据倒入弹出栈，3.由弹出栈再弹出数据 15 | #先保证弹出栈中数据都已经弹出 16 | if self.stackpop: 17 | return self.stackpop.pop() 18 | 19 | #如果弹出栈为空，则进行上述过程 20 | if self.stackpush == None: 21 | return None 22 | else: 23 | #当压入栈中的所有数据都倒入弹出栈 24 | while self.stackpush: 25 | self.stackpop.append(self.stackpush.pop()) 26 | return self.stackpop.pop() 27 | -------------------------------------------------------------------------------- /堆排序算法: -------------------------------------------------------------------------------- 1 | """ 2 | A:数组 3 | i:父节点的index 4 | size:堆的大小 5 | """ 6 | 7 | def heap_adjust(A,i,size): 8 | left = 2*i+1 9 | right = 2*i+2 10 | max_index = i 11 | if left < size and A[left] > A[max_index] : 12 | max_index = left 13 | if right < size and A[right] > A[max_index]: 14 | max_index = right 15 | if max_index != i: 16 | temp = A[i] 17 | A[i] =A[max_index] 18 | A[max_index] = temp 19 | heap_adjust(A,max_index,size) #以替换的点为父节点，再调整所在的堆 20 | 21 | def build_heap(A,size): 22 | for i in range(size//2,-1,-1): 23 | heap_adjust(A,i,size) 24 | 25 | def heap_sort(A): 26 | size = len(A) 27 | build_heap(A,size) #初始化堆 28 | for i in range(len(A)-1,0,-1): 29 | temp = A[i] 30 | A[i] = A[0] 31 | A[0] = temp #将最大元素置于数组后的位置 32 | heap_adjust(A,0,i) 33 | return A 34 | 35 | 36 | nums = [9,8,7,6,5,4,3,2,1] 37 | print(heap_sort(nums)) 38 | -------------------------------------------------------------------------------- /归并排序: -------------------------------------------------------------------------------- 1 | #分冶法 2 | 3 | #将两个数组从大到小合并 4 | def merge(left, right): 5 | i = 0 6 | j = 0 7 | res = [] 8 | while i < len(left) and j < len(right): 9 | if left[i] < right[j]: 10 | res.append(left[i]) 11 | i += 1 12 | else: 13 | res.append(right[j]) 14 | j += 1 15 | res += left[i:] 16 | res += right[j:] 17 | return res 18 | 19 | def merge_sort(nums): 20 | n = len(nums) 21 | if n <= 1: 22 | return nums 23 | mid = n//2 24 | left = merge_sort(nums[:mid]) 25 | right = merge_sort(nums[mid:]) 26 | return merge(left, right) 27 | 28 | nums = [1,4,2,6,4,9,2,5] 29 | print(merge_sort(nums)) 30 | -------------------------------------------------------------------------------- /快速排序: -------------------------------------------------------------------------------- 1 | def quick_sort(nums): 2 | if len(nums) <= 1: 3 | return nums 4 | key = nums.pop() 5 | left = [] 6 | right = [] 7 | for x in nums: 8 | if x < key: 9 | left.append(x) 10 | else: 11 | right.append(x) 12 | return quick_sort(left) + [key] + quick_sort(right) 13 | -------------------------------------------------------------------------------- /推箱子问题: -------------------------------------------------------------------------------- 1 | 题目描述 2 | 有重量分别为3，5，7公斤的三种货物，和一个载重量为X公斤的箱子（不考虑体积等其它因素，只计算重量）需要向箱子内装满X公斤的货物， 3 | 要求使用的货物个数尽可能少（三种货物数量无限） 4 | 输入描述: 5 | 输入箱子载重量X(1 <= X <= 10000)，一个整数。 6 | 输出描述: 7 | 如果无法装满，输出 -1。 8 | 如果可以装满，输出使用货物的总个数。 9 | 示例1 10 | 输入 11 | 4 12 | 输出 13 | -1 14 | 说明 15 | 无法装满 16 | 示例2 17 | 输入 18 | 8 19 | 输出 20 | 2 21 | 说明 22 | 使用1个5公斤，1个3公斤货物 23 | 24 | def packbox(x): 25 | dp = {} 26 | for i in range(1,x+1): 27 | dp[i] = -1 28 | dp[3] = 1 29 | dp[5] = 1 30 | dp[7] = 1 31 | dp[6] = 2 32 | for j in range(8,x+1): 33 | if dp[j-7] != -1: 34 | dp[j] = dp[j-7] + 1 35 | elif dp[j-5] != -1: 36 | dp[j] = dp[j-5] + 1 37 | elif dp[j-3] != -1: 38 | dp[j] = dp[j-3] + 1 39 | return dp[x] 40 | -------------------------------------------------------------------------------- /插入排序: -------------------------------------------------------------------------------- 1 | #从索引1元素a开始,依次和前面比较(从后往前),当该元素a小于已经排序好元素b,那么b向后移一位.最后肯定留一个"坑",把a塞进去. 2 | def insertions_sort(nums): 3 | for i in range(1,len(nums)): 4 | temp = nums[i] 5 | j = i-1 6 | while j >= 0 and nums[j] > temp: 7 | nums[j+1] = nums[j] 8 | j -= 1 9 | nums[j+1] = temp 10 | return nums 11 | 12 | nums = [1,4,2,6,4,9,2,5] 13 | print(insertions_sort(nums)) 14 | -------------------------------------------------------------------------------- /选择排序: -------------------------------------------------------------------------------- 1 | #遍历数组,每次都把最小的放到相应位置 2 | def select_sort(nums): 3 | n = len(nums) 4 | for i in range(n-1): 5 | for j in range(i,n-1): 6 | if nums[i] > nums[j]: 7 | nums[i],nums[j] = nums[j],nums[i] 8 | return nums 9 | 10 | nums = [1,4,2,6,4,9,2,5] 11 | print(select_sort(nums)) 12 | -------------------------------------------------------------------------------- /面试指南-1.1 最小栈: -------------------------------------------------------------------------------- 1 | 1.1 最小栈 2 | 3 | 设计一个支持 push，pop，top 操作，并能在常数时间内检索到最小元素的栈。 4 | 5 | push(x) -- 将元素 x 推入栈中。 6 | pop() -- 删除栈顶的元素。 7 | top() -- 获取栈顶元素。 8 | getMin() -- 检索栈中的最小元素。 9 | 10 | 11 | class MinStack: 12 | 13 | def __init__(self): 14 | """ 15 | initialize your data structure here. 16 | """ 17 | #定义一个列表 18 | self.stack = [] 19 | 20 | #push(x) -- 将元素 x 推入栈中。 21 | def push(self, x: int) -> None: 22 | self.stack.append(x) 23 | 24 | #pop() -- 删除栈顶的元素。 25 | def pop(self) -> None: 26 | length = len(self.stack) 27 | self.stack = self.stack[:length-1] 28 | 29 | #top() -- 获取栈顶元素。 30 | def top(self) -> int: 31 | return self.stack[-1] 32 | 33 | #getMin() -- 检索栈中的最小元素。 34 | def getMin(self) -> int: 35 | return min(self.stack) 36 | 37 | 38 | # Your MinStack object will be instantiated and called as such: 39 | # obj = MinStack() 40 | # obj.push(x) 41 | # obj.pop() 42 | # param_3 = obj.top() 43 | # param_4 = obj.getMin() 44 | -------------------------------------------------------------------------------- /面试指南-1.2 由两个栈组成的队列: -------------------------------------------------------------------------------- 1 | 1.2 由两个栈组成的队列 2 | 3 | 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。 4 | 5 | class Solution: 6 | #定义一个栈作为压入栈，在压入数据时，只往这个栈压入； 7 | #另一个栈只为弹出栈，只从这个栈弹出数据 8 | def __init__(self): 9 | self.stackpush = [] 10 | self.stackpop = [] 11 | def push(self, node): 12 | self.stackpush.append(node) 13 | def pop(self): 14 | #要实现队列的先进先出，也就是1.先把数据压入压入栈，2.再把压入栈中的数据倒入弹出栈，3.由弹出栈再弹出数据 15 | #先保证弹出栈中数据都已经弹出 16 | if self.stackpop: 17 | return self.stackpop.pop() 18 | 19 | #如果弹出栈为空，则进行上述过程 20 | if self.stackpush == None: 21 | return None 22 | else: 23 | #当压入栈中的所有数据都倒入弹出栈 24 | while self.stackpush: 25 | self.stackpop.append(self.stackpush.pop()) 26 | return self.stackpop.pop() 27 | --------------------------------------------------------------------------------