剑指offer算法题python实现
文章目录
-
- 1. 二维数组中的查找[Done]
- 2. 替换空格[Done]
- 3. 从尾到头打印链表[Done]
- 4. 由前序和中序遍历求树结构[***]
- 5. 用两个堆栈实现队列[Done]
- 6. 旋转数组的最小数字[**][Done]
- 7. 斐波那契数列[Done]
- 8. 跳台阶[Done]
- 9.变态跳台阶[Done]
- 10. 矩形覆盖[**][Done]
- 11. 二进制中1的个数[***][DONE]
- 12. 数的整次方[DONE]
- 13. 调整数组顺序使奇数位于偶数前面[**][ Done]
- 14.输出链表中倒数第K个节点[***][Done]
- 15. 链表反转[Done]
- 16.合并两个排序的链表[Done]
- 17. 树的子结构[***]
- 18. 二叉树的镜像[***][Done]
- 19.顺时针打印矩阵[Done]
- 20. 包含min的栈[*]
- 21(2). 包含max的队列
- 21. 栈的压入弹出顺序[Done]
- 22.从上往下打印二叉树[Done]
- 23. 二叉搜索树的后序遍历序列[***]
- 24. 二叉树中和为某一值得路径[***]
- 25. 复杂链表的复制[*]
- 26. 二叉树搜索和双向链表[***]
- 27. 字符串排列[***]
- 28. 数组中出现次数超过一半的数字[Done]
- 29. 最小的K个数[***][Done]
- 30. 连续子数组最大和[***][Done]
- 31.从1到n的整数中1出现的次数
- 32. 把数组排成最小的数[***]
- 33. 丑数
- 34. 第一个只出现一次的字符
- 35. 数组中的逆序对[**][****]
- 36. 两个链表的第一个公共节点
- 37. 数字在排序数组中的次数
- 38. 二叉树的深度
- 39.平衡二叉树[Done]
- 40. 数组中只出现一次的数字
- 41. 和为s的连续正数序列
- 42. 和为S的两个数字[Done]
- 43. 左旋转字符串[Done]
- 44. 反转字符串[Done]
- 45. 扑克牌顺子
- 46.圆圈中剩下的数
- 47. 求1+2+...+n
- 48. 不用加减乘除做加法
- 49.字符串转换成整数
- 50.数组中重复的数字
- 51. 构建乘积数组
- 52. 正则表达式匹配
- 53. 表示数值的字符串
- 54. 字符流中第一个不重复的字符
- 55. 链表中环的入口节点
- 56. 删除列表中的重复节点
- 57. 二叉树下一个节点
- 58. 对称二叉树
- 59.按之字形顺序打印二叉树
- 60. 将二叉树打印成多行
- 61. 序列化二叉树
- 62. 二叉搜索树的第K个节点
- 63. 数据流中的中位数
- 64. 滑动窗口中的最大值
- 65. 矩阵中的路径
- 66.机器人运动范围
- 67. 剪绳子
- 参考
本文题目顺序按照 牛客网 | 挑战剑指offer [1]中题目顺序，相关参考资料见文末
1. 二维数组中的查找[Done]
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路1
暴力法，遍历二维数组比较是否有与目标值相等的元素
思路2
将二维数组的左下角作为起始点，如果目标值大于当前元素，就横坐标加一，若目标值小于当前元素，纵坐标减1（当然也可以考虑右上方作为起始点）
思路1暴力法最差的复杂度为 m n mn mn，其中 m m m， n n n分别为二维矩阵的长宽，而思路而最差的复杂度为 m + n m+n m+n
程序(思路2)
class Solution:
# array 二维列表
def Find(self, target, array):
# write code here
rows = len(array)-1
cols = len(array[0])-1
i = rows
j = 0
while i>=0 and j<=cols:
if target < array[i][j]:
i -= 1
elif target > array[i][j]:
j += 1
else:
return True
return False
2. 替换空格[Done]
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy
class Solution:
# s 源字符串
def replaceSpace(self, s):
# write code here
temp = s.replace(" ", "%20")
return temp
# -*- coding:utf-8 -*-
class Solution:
# s 源字符串
def replaceSpace(self, s):
# write code here
result = ""
for x in s:
if x == " ":
result += "%20"
else:
result += x
return result
3. 从尾到头打印链表[Done]
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
class Solution:
# 返回从尾部到头部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
# write code here
stack = []
while listNode != None:
stack.append(listNode.val)
listNode = listNode.next
stack.reverse()
return stack
4. 由前序和中序遍历求树结构[***]
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回
第一种递归
class Solution:
# 返回构造的TreeNode根节点
def reConstructBinaryTree(self, pre, tin):
# write code here
if not pre:
return None
rootval = pre[0]
root = TreeNode(rootval)
index = tin.index(rootval)
root.left = self.reConstructBinaryTree(pre[1:index+1], tin[:index])
root.right = self.reConstructBinaryTree(pre[index+1:], tin[index+1:])
return root
第二种递归
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
def reConstructBinaryTree(pre, tin):
# write code here
def helper(left, right):
nonlocal preidx
if left == right:
return None
rootval = pre[preidx]
root = TreeNode(rootval)
idx = tin.index(rootval)
preidx += 1
root.left = helper(left, idx)
root.right = helper(idx+1, right)
return root
preidx = 0
return helper(0, len(tin))
# 以下为测试程序
preorder = [3,9,20,15,7]
inorder = [9,3,15,20,7]
root = reConstructBinaryTree(preorder, inorder)
# 前序遍历
def preor(head):
if head != None:
print(head.val, end="\t")
preor(head.left)
preor(head.right)
# 中序遍历
def inor(head):
if head != None:
inor(head.left)
print(head.val, end="\t")
inor(head.right)
preor(root)
print()
inor(root)
方法3
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
def recursion(preorder, inorder):
if not inorder or not preorder:
return None
node = preorder.pop(0)
idx = inorder.index(node)
left = inorder[:idx]
right = inorder[idx+1:]
root = TreeNode(node)
root.left = recursion(preorder, left)
root.right = recursion(preorder, right)
return root
return recursion(preorder, inorder)
5. 用两个堆栈实现队列[Done]
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型
class Solution:
def __init__(self):
self.stack1 = []
self.stack2 = []
def push(self, node):
# write code here
self.stack1.append(node)
def pop(self):
# return xx
while self.stack1:
self.stack2.append(self.stack1.pop())
result = self.stack2.pop()
while self.stack2:
self.stack1.append(self.stack2.pop())
return result
方法2
用stack1专门用于push, stack2专门用于pop
class Solution:
def __init__(self):
self.stack1 = []
self.stack2 = []
def push(self, node):
# write code here
self.stack1.append(node)
def pop(self):
# return xx
# 如果stack2为空， 将stack1元素放到stack2中
if not self.stack2:
while self.stack1:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
6. 旋转数组的最小数字[**][Done]
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
注意：
题目描述的并不好，题目实际意思为：一个递增数组，将其按上面题目描述的方式旋转，给出旋转后的数组，求该数组的最小值
思路1：暴力法
由于为旋转前数组是递增的，因此 a [ i ] > a [ i − 1 ] a[i]>a[i-1] a[i]>a[i−1]；当数组旋转后，即最小值放到了中间某一位置，因此若存在 a [ i ] < a [ i − 1 ] a[i]
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
if len(rotateArray) == 0:
return 0
for i in range(1, len(rotateArray)):
if rotateArray[i]<rotateArray[i-1]:
return rotateArray[i]
# 若未旋转，返回第一个元素，即最小值
return rotateArray[0]
时间复杂度： O ( n ) O(n) O(n)
思路2：二分法
每次都用中间元素与最右边元素相比较，如果中间元素大于最右边元素，则最小值在中间元素的右边，如果中间元素小于最右边元素，最小值在中间元素的左边。
时间复杂度为 O ( l o g n ) O(logn) O(logn)
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
if len(rotateArray) == 0:
return 0
left = 0
right = len(rotateArray)-1
while left < right:
mid = (left + right)//2
if rotateArray[mid] > rotateArray[right]:
left = mid + 1
else:
right = mid
return rotateArray[left]
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
if len(rotateArray) == 0:
return 0
left = 0
right = len(rotateArray)-1
def bisearch(left, right):
if left == right:
return rotateArray[left]
mid = (left+right)//2
if rotateArray[mid]>rotateArray[right]:
left = mid+1
else:
right = mid
return bisearch(left,right)
return bisearch(left, right)
7. 斐波那契数列[Done]
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39
提示
斐波那契数列： F ( 1 ) = 1 ， F ( 2 ) = 1 , F ( n ) = F ( n − 1 ) + F ( n − 2 ) （ n > = 3 ， n ∈ N ∗ ） F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*） F(1)=1，F(2)=1,F(n)=F(n−1)+F(n−2)（n>=3，n∈N∗）
代码1：
class Solution:
def Fibonacci(self, n):
# write code here
if n == 0:
return 0
if n == 1 or n==2:
return 1
dp = [0]*(n+1)
dp[1] = 1
dp[2] =1
for i in range(3, n+1):
dp[i] = dp[i-2]+dp[i-1]
return dp[n]
时间复杂度： O ( n ) O(n) O(n)
空间复杂度： O ( n ) O(n) O(n)
代码2（对代码1的改进）
class Solution:
def Fibonacci(self, n):
# write code here
if n == 0:
return 0
if n == 1 or n==2:
return 1
a = b = 1
for i in range(3, n+1):
a, b = b, a+b
return b
时间复杂度 O ( n ) O(n) O(n)
空间复杂度 O ( 1 ) O(1) O(1)
8. 跳台阶[Done]
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路
每次跳都有两种选择，即跳一个台阶和跳两个台阶，则青蛙到第n个台阶的跳法为：从第 n − 1 n-1 n−1台阶跳一个台阶和第 n − 2 n-2 n−2台阶跳2个台阶，总的跳法个数为 f ( n − 1 ) + f ( n − 2 ) f(n-1)+f(n-2) f(n−1)+f(n−2)， f ( n ) f(n) f(n)表示跳到第n个台阶的跳法数。注意 f ( 0 ) = 0 , f ( 1 ) = 1 , f ( 2 ) = 2 f(0)=0, f(1)=1, f(2)=2 f(0)=0,f(1)=1,f(2)=2
class Solution:
def jumpFloor(self, number):
# write code here
if number <= 2:
return number
else:
a, b = 1, 2
for i in range(3, number+1):
a, b = b, a+b
return b
时间复杂度 O ( n ) O(n) O(n)
9.变态跳台阶[Done]
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路
f(n) = n, n<=2
f(n) = f(1)+f(2)+...+f(n-1)+1, n>2
代码1
class Solution:
def jumpFloorII(self, number):
# write code here
if number <= 2:
return number
else:
dp = [0]*(number+1)
dp[1] = 1
dp[2] = 2
for i in range(3, number+1):
dp[i] = sum(dp[:i])+1
return dp[number]
代码1改进
f(n) = f(1)+f(2)+...+f(n-1)+1, n>2
f(n-1) = f(1)+f(2)+...+f(n-2)+1, n>2
所以
f(n) = f(1)+f(2)+...+f(n-2)+f(n-1)+1 = f(n-1)-1+f(n-1)+1 = 2f(n-1) n>2
f(n) = 2^2f(n-2) = 2^3f(n-3)= ...= 2^(n-2)f(n-(n-2))=2^(n-2)f(2) = 2^(n-1)
class Solution:
def jumpFloorII(self, number):
# write code here
if number <= 2:
return number
else:
return 2**(number-1)
10. 矩形覆盖[**][Done]
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
比如n=3时，2*3的矩形块有3种覆盖方法：
思路
n = 1 时，return 1
n = 2时， return 2
当n大于等于3时，假设n = k时， 此时覆盖方法可以是n=k-1的覆盖方法后面再加一个竖着放的长方体， 也可以是n = k-2时覆盖方法后面横着放2个长方体（不能竖着放两个长方体，因为竖着放一个就和k-1相同了）
因此，当n>2时：
f ( n ) = f ( n − 1 ) + f ( n − 2 ) f(n) = f(n-1)+f(n-2) f(n)=f(n−1)+f(n−2)
class Solution:
def rectCover(self, number):
# write code here
if number <= 2:
return number
else:
a, b = 1, 2
for i in range(3, number+1):
a, b = b, a+b
return b
11. 二进制中1的个数[***][DONE]
题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路
如果整数不等于0，那么该整数的二进制表示中至少有1位是1。
先假设这个数的最右边一位是1，那么该数减去1后，最右边一位变成了0，其他位不变。
再假设最后一位不是1而是0，而最右边的1在第m位，那么该数减去1，第m位变成0，m右边的位变成1，m之前的位不变。
上面两种情况总结，一个整数减去1，都是把最右边的1变成0，如果它后面还有0，那么0变成1。那么我们把一个整数减去1,与该整数做位运算，相当于把最右边的1变成了0，比如1100与1011做位与运算，得到1000。那么一个整数中有多少个1就可以做多少次这样的运算。
class Solution:
def NumberOf1(self, n):
# write code here
count = 0
# 如果n是负数，将其补码变成普通的数（无符号数）
if n < 0:
n = n & 0xffffffff
while n:
n = (n-1)&n
count = count + 1
return count
当n<0时为何要进行n = n & 0xffffffff?
如下python计算结果，而对于java等编程语言会自动去除最高的溢出位，故计算结果正确，而python不会去除最高溢出位，故计算错误
12. 数的整次方[DONE]
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0
class Solution:
def Power(self, base, exponent):
# write code here
if exponent == 0:
return 1
if base == 0:
return 0
result = 1
n = abs(exponent)
while n:
result *= base
n -= 1
return result if exponent >0 else 1/result
13. 调整数组顺序使奇数位于偶数前面[**][ Done]
题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变
程序1：使用两个额外空间
class Solution:
def reOrderArray(self, array):
# write code here
jishu = []
oushu = []
for x in array:
if x%2 == 0:
oushu.append(x)
else:
jishu.append(x)
return jishu+oushu
程序2：不使用额外空间
class Solution:
def reOrderArray(self, array):
# write code here
p1 = 0
while p1 < len(array):
# 从头开始找到第一个偶数
while p1<len(array) and array[p1]%2 != 0:
p1 += 1
p2 = p1 + 1
# 在偶数后找到第一个奇数
while p2<len(array) and array[p2]%2 == 0:
p2 += 1
# 将第一个奇数查到偶数的位置
if p2 < len(array):
array.insert(p1, array.pop(p2))
else:
break
return array
程序3
def resort(data):
for i in range(1, len(data)):
if data[i]%2 != 0 and data[i-1]%2==0:
j = i-1
temp = data[i]
while j>=0 and data[j]%2 == 0:
data[j+1] = data[j]
j -= 1
data[j+1] = temp
return data
data = [1,2,3,4,5,6,7,9]
print(resort(data))
14.输出链表中倒数第K个节点[***][Done]
输入一个链表，输出该链表中倒数第k个结点。
程序1 使用额外空间
class Solution:
def FindKthToTail(self, head, k):
# write code here
# 若链表为空链表或k值<=0：返回None
if head == None or k <= 0:
return None
result = []
ptr = head
while ptr != None:
result.append(ptr)
ptr = ptr.next
# 若k值超出链表的长度，返回None
if len(result)<k:
return None
return result[-k]
程序2：程序1的改进，不使用额外空间
假设链表中的节点数大于等于k个，那么一定会存在倒数第k个节点，首先使用一个快指针先往前走k步，然后两个指针每次走一步，两个指针之间始终有k的距离，当快指针走到末尾时，慢指针所在的位置就是倒数第k个节点
class Solution:
def FindKthToTail(self, head, k):
# write code here
if head == None or k <= 0:
return None
p = q = head
t = 0
while p!=None and t<k:
p = p.next
t += 1
# 判断k是否超过链表长度
if t < k:
return None
while p!=None:
p = p.next
q = q.next
return q
15. 链表反转[Done]
输入一个链表，反转链表后，输出新链表的表头。
class Solution:
# 返回ListNode
def ReverseList(self, pHead):
# write code here
if pHead == None:
return None
p = pHead
r = None
while p!=None:
q = p
p = p.next
q.next = r
r = q
return q
递归方法
data = [1,2,3,4,5,6]
class ListNode:
def __init__(self, val):
self.val = val
self.next = None
# 构建链表
head = ListNode(data[0])
ptr = head
for val in data[1:]:
node = ListNode(val)
ptr.next = node
ptr = ptr.next
# 链表反转
def inverse(head):
if head == None or head.next == None:
return head
# 一直循环到链尾
newHead = inverse(head.next)
# 翻转链表指向
head.next.next = head
head.next = None
return newHead
# 打印链表
newHead = inverse(head)
while newHead != None:
print(newHead.val, end="\t")
newHead = newHead.next
16.合并两个排序的链表[Done]
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
def Merge(self, pHead1, pHead2):
# write code here
result = ListNode(0)
reHead = result
while pHead1 and pHead2:
if pHead1.val>pHead2.val:
result.next = pHead2
pHead2 = pHead2.next
result = result.next
else:
result.next = pHead1
pHead1 = pHead1.next
result = result.next
if pHead1:
result.next = pHead1
elif pHead2:
result.next = pHead2
return reHead.next
17. 树的子结构[***]
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
思路
采用递归的思路，单独定义一个函数判断B是不是从当前A的根节点开始的子树，这里判断是不是子树也需要一个递归的判断。如果是，则返回True，如果不是，再判断B是不是从当前A的根节点的左子节点或右子节点开始的子树
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 判断从当前节点算起，是不是子树
def isSubtree(self, root1, root2):
# 因为是判读root2是不是root1的子结构，因此当root2=None时代表root2已经到遍历到末尾，此时返回True
if not root2:
return True
# 若root2还没遍历完，root1已经遍历完，直接返回False
if not root1:
return False
if root1.val != root2.val:
return False
return self.isSubtree(root1.left, root2.left) and self.isSubtree(root1.right, root2.right)
# 主函数
def HasSubtree(self, pRoot1, pRoot2):
# write code here
if not pRoot1 or not pRoot2:
return False
result = False
# 判断root2是否为root1为开始节点的子树
if pRoot1.val == pRoot2.val:
result = self.isSubtree(pRoot1, pRoot2)
# 若不是以root1为开始节点的子树，接着判断是否为root1.left为开始节点的子树
if not result:
result = self.HasSubtree(pRoot1.left, pRoot2)
# 若上述两个条件都不满足，判断是否为root1.right为开始节点的子树
if not result:
result = self.HasSubtree(pRoot1.right, pRoot2)
return result
18. 二叉树的镜像[***][Done]
操作给定的二叉树，将其变换为源二叉树的镜像
交换左右节点
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
# write code here
if root == None:
return
temp = root.left
root.left = root.right
root.right = temp
self.Mirror(root.left)
self.Mirror(root.right)
return root
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
# write code here
if root == None:
return None
else:
root.left, root.right = self.Mirror(root.right), self.Mirror(root.left)
return root
19.顺时针打印矩阵[Done]
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： [[1 2 3 4 ][5 6 7 8 ][9 10 11 12 ][13 14 15 16]]则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
思路：
每打印matrix一行后就将matrix逆时针旋转90度
class Solution:
# matrix类型为二维列表，需要返回列表
def printMatrix(self, matrix):
# write code here
if not matrix:
return None
result = []
while matrix:
result += matrix.pop(0)
if not matrix:
break
matrix = self.turn(matrix)
return result
def turn(self, matrix):
result = []
for i in range(len(matrix[0])):
temp = []
for j in range(len(matrix)):
temp.append(matrix[j][i])
result.append(temp)
result.reverse()
return result
20. 包含min的栈[*]
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
注意：保证测试中不会当栈为空的时候，对栈调用pop()或者min()或者top()方法。
class Solution:
def __init__(self):
self.stack = []
self.minnum = []
def push(self, node):
# write code here
self.stack.append(node)
if not self.minnum or node<self.minnum[-1]:
self.minnum.append(node)
else:
self.minnum.append(self.minnum[-1])
def pop(self):
# write code here
self.minnum.pop()
if self.stack:
return self.stack.pop()
else:
return None
def top(self):
# write code here
return self.stack[-1]
def min(self):
if self.minnum:
return self.minnum[-1]
else:
return None
21(2). 包含max的队列
使用两个栈来实现
class Queue:
def __init__(self):
self.stack1 = []
self.stack2 = []
self.stack1_max = []
self.stack2_max = []
# 入队
def enqueue(self, val):
self.stack1.append(val)
if not self.stack1_max:
self.stack1_max.append(val)
else:
self.stack1_max.append(max(self.stack1_max[-1], val))
# 出队
def dequeue(self):
if self.stack2:
self.stack2_max.pop()
return self.stack2.pop()
else:
while self.stack1:
temp = self.stack1.pop()
self.stack2.append(temp)
if not self.stack2_max:
self.stack2_max.append(temp)
else:
self.stack2_max.append(max(self.stack2_max[-1], temp))
self.stack1_max.pop()
self.stack2_max.pop()
return self.stack2.pop()
# 最大值
def maxNum(self):
if self.stack2 and (not self.stack1):
return self.stack2_max[-1]
elif self.stack1 and (not self.stack2):
return self.stack1_max[-1]
else:
return self.stack1_max[-1] if self.stack1_max[-1] > self.stack2_max[-1] else self.stack2_max[-1]
if __name__ == "__main__":
queue = Queue()
queue.enqueue(1)
queue.enqueue(5)
queue.enqueue(4)
print(queue.maxNum())
21. 栈的压入弹出顺序[Done]
题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
思路1
栈的特点是先进后出，所以只需考虑出栈元素的顺序是否先进后出；当然存在一些小细节，以实际例子讲解：设pushV = [1,2,3,4,5], popV = [4,5,3,2,1], 那么popV[0] = 4, 我们只需考虑pushV中[1,2,3,4]这几个数字的出栈顺序，而popV[1]=5>4, 而4前面的数字顺序都考虑过了，我们只需考虑（4， 5]，即只有一个数字5的顺序，再往后，3，2，1 都比5小我们已经考虑过其出栈顺序，故不需再考虑。
class Solution:
def IsPopOrder(self, pushV, popV):
# write code here
maxnum = -float("inf")
# 遍历popV的每个元素
for i in range(len(popV)):
# 如果popV中元素在pushV中不存在，直接False
if popV[i] not in pushV:
return False
# 该步骤是用于提前结束循环
if popV[i] < maxnum:
continue
else:
maxnum = popV[i]
# 记录起始索引
idx1 = 0 if i ==0 else pushV.index(popV[i-1])+1
index = pushV.index(popV[i])
temp = pushV[idx1:index+1]
# 检查出栈顺序
for i in range(len(temp)-1):
if popV.index(temp[i])<popV.index(temp[i+1]):
return False
return True
思路2：使用辅助栈
class Solution:
def IsPopOrder(self, pushV, popV):
# write code here
help = []
for x in pushV:
help.append(x)
while help and help[-1] == popV[0]:
help.pop()
popV.pop(0)
if help:
return False
else:
return True
22.从上往下打印二叉树[Done]
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
思路：二叉树的层序遍历
class Solution:
# 返回从上到下每个节点值列表，例：[1,2,3]
def PrintFromTopToBottom(self, root):
if not root:
return []
# write code here
nodes = [root]
result = []
while nodes:
node = nodes.pop()
result.append(node.val)
if node.left:
nodes.insert(0, node.left)
if node.right:
nodes.insert(0, node.right)
return result
23. 二叉搜索树的后序遍历序列[***]
输入一个非空整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路：
如果序列的长度小于2，那一定是后序遍历的结果。根据BST和后序遍历的性质，遍历结果的最后一个一定是根节点，那么序列中前面一部分小于根节点的数是左子树，后一部分是右子树，递归进行判断。
# -*- coding:utf-8 -*-
class Solution:
def VerifySquenceOfBST(self, sequence):
# write code here
if len(sequence) == 0:
return False
return self.help(sequence)
def help(self, sequence):
if len(sequence) <=2:
return True
flag = sequence[-1]
i = 0
while sequence[i]<flag:
i += 1
index = i
while i<len(sequence)-1:
if sequence[i]<flag:
return False
else:
i+=1
return self.help(sequence[:index]) and self.help(sequence[index:-1])
24. 二叉树中和为某一值得路径[***]
题目描述
输入一颗二叉树的根节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
class Solution:
# 返回二维列表，内部每个列表表示找到的路径
def FindPath(self, root, expectNumber):
if not root:
return []
# write code here
self.result = []
self.help(root, expectNumber,[])
return self.result
def help(self, root, number, res):
if not root.left and not root.right:
if root.val == number:
res += [root.val]
self.result.append(res)
if root.left:
self.help(root.left, number-root.val, res+[root.val])
if root.right:
self.help(root.right, number-root.val, res+[root.val])
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回二维列表，内部每个列表表示找到的路径
def FindPath(self, root, expectNumber):
# write code here
self.result = []
self.temp = []
if not root:
return []
self.help(root, expectNumber)
return self.result
def help(self, root, num):
if not root.left and not root.right:
self.temp.append(root.val)
if sum(self.temp) == num:
self.result.append(self.temp[:])
return
self.temp.append(root.val)
if root.left:
self.help(root.left, num)
self.temp.pop()
if root.right:
self.help(root.right, num)
self.temp.pop()
25. 复杂链表的复制[*]
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
# -*- coding:utf-8 -*-
# class RandomListNode:
# def __init__(self, x):
# self.label = x
# self.next = None
# self.random = None
class Solution:
# 返回 RandomListNode
def Clone(self, pHead):
# write code here
if pHead == None:
return None
newhead = RandomListNode(pHead.label)
newhead.random = pHead.random
newhead.next = self.Clone(pHead.next)
return newhead
26. 二叉树搜索和双向链表[***]
题目描述
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
思路1：暴力法，中序遍历取出所有的节点，然后将各个节点连接
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Convert(self, pRootOfTree):
if not pRootOfTree:
return None
# write code here
self.nodes = []
self.inorder(pRootOfTree)
print(self.nodes)
i, j = 0, 1
while j < len(self.nodes):
self.nodes[j].left = self.nodes[i]
self.nodes[i].right = self.nodes[j]
i += 1
j += 1
self.nodes[0].left = None
self.nodes[-1].right = None
return self.nodes[0]
def inorder(self, pRootOfTree):
if pRootOfTree != None:
self.inorder(pRootOfTree.left)
self.nodes.append(pRootOfTree)
self.inorder(pRootOfTree.right)
思路2：对思路1的改进
从中序遍历得到的第一个节点开始构造链表，定义两个辅助节点listHead(链表头节点)、listTail(链表尾节点)。listHead用于记录链表的头节点，用于最后算法的返回；listTail用于定位当前需要更改指向的节点
class Solution:
def Convert(self, pRootOfTree):
if not pRootOfTree:
return None
# write code here
self.listhead = None
self.listtail = None
self.inorder(pRootOfTree)
return self.listhead
def inorder(self, pRootOfTree):
if pRootOfTree == None:
return None
self.inorder(pRootOfTree.left)
if not self.listhead:
self.listhead = pRootOfTree
self.listtail = pRootOfTree
else:
self.listtail.right = pRootOfTree
pRootOfTree.left = self.listtail
self.listtail = pRootOfTree
self.inorder(pRootOfTree.right)
27. 字符串排列[***]
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
class Solution:
def Permutation(self, ss):
if not ss:
return []
# write code here
length = len(ss)
isused = [False]*len(ss)
temp = []
result = []
self.help(ss, isused, temp, result)
return result
def help(self, ss, isused, temp, result):
if len(temp) == len(ss):
te = "".join(temp)
if te not in result:
result.append("".join(temp))
for i in range(len(ss)):
if isused[i]:
continue
else:
temp.append(ss[i])
isused[i] = True
self.help(ss, isused, temp, result)
temp.pop()
isused[i] = False
def digui(s, res, result, isused):
if len(res)==len(s):
result.append(res.copy())
for i in range(len(s)):
if not isused[i]:
res += s[i]
isused[i] = True
digui(s, res, result, isused)
isused[i] = False
res.pop()
result = []
s = "abc"
isused = [False]*len(s)
digui(s, [], result, isused)
print(result)
思路2：
把字符串分为两个部分： 字符串的第一个字符，第一个字符后面的所有字符。1.求所有可能出现在第一个位置的字符，用索引遍历。2.求第一个字符以后的所有字符的全排列。将后面的字符又分成第一个字符以及剩余字符。
class Solution:
def Permutation(self, ss):
if not ss:
return []
if len(ss) == 1:
return [ss]
path = ""
result = []
self.helper(ss, path, result)
return sorted(list(set(result)))
def helper(self, ss, path, result):
if not ss:
result.append(path)
for i in range(len(ss)):
self.helper(ss[:i]+ss[i+1:], path+ss[i], result)
28. 数组中出现次数超过一半的数字[Done]
题目描述
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
思路1：暴力法
class Solution:
def MoreThanHalfNum_Solution(self, numbers):
# write code here
num = len(numbers)/2
for x in set(numbers):
if numbers.count(x)>num:
return x
else:
return 0
思路二：中位数法
如果存在一个数的出现次数大于数组长度的一半，那么经过排序后，数组的中位数必定是该数
class Solution:
def MoreThanHalfNum_Solution(self, numbers):
# write code here
numbers.sort()
temp = numbers[len(numbers)//2]
if numbers.count(temp)>len(numbers)//2:
return temp
else:
return 0
29. 最小的K个数[***][Done]
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
思路
先使用堆排序对给定数据的前k个数进行排序（使用最大堆），然后遍历data[k:]，如果data[j]小于堆根，将该数替换成堆根。最后得到的堆就是最小的K个数
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
if k<=0 or len(tinput)<k:
return []
temp = tinput[:k]
self.buildMaxHeap(temp)
for i in range(k, len(tinput)):
if tinput[i]<temp[0]:
temp[0]=tinput[i]
self.heapify(temp, 0)
return sorted(temp)
# 建立堆排序
def buildMaxHeap(self, data):
global length
length = len(data)
for i in range(len(data)//2, -1, -1):
self.heapify(data, i)
def heapify(self, data, i):
left = 2*i+1
right = 2*i+2
largest = i
if left < length and data[left]>data[largest]:
largest = left
if right < length and data[right]>data[largest]:
largest = right
if largest != i:
data[largest], data[i] = data[i], data[largest]
self.heapify(data, largest)
30. 连续子数组最大和[***][Done]
题目描述
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
思路
如果数组里所有的整数都是负数，那么选择最大的数即可，因为越累加越小。
正负数都有的情况，需要两个变量，一个是global_max,从全局来看，每次最大的是什么组合，另一个是local_max，和global_max相比，更新global_max。
class Solution:
def FindGreatestSumOfSubArray(self, array):
# write code here
if max(array)<0:
return max(array)
local_max, global_max = 0, 0
for x in array:
# local_max每次都从一个正数开始加直到加到小于零，再从另外一个正数加
local_max = max(0, local_max+x)
global_max = max(global_max, local_max)
return global_max
31.从1到n的整数中1出现的次数
题目描述
求出1-13的整数中1出现的次数,并算出100-300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
思路1：暴力法
class Solution:
def NumberOf1Between1AndN_Solution(self, n):
# write code here
result = 0
for x in range(1, n+1):
result += self.helper(x)
return result
def helper(self, x):
count = 0
while x>0:
if x%10 == 1:
count += 1
x = x//10
return count
32. 把数组排成最小的数[***]
题目描述
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
from functools import cmp_to_key
def PrintMinNumber(numbers):
if not len(numbers):
return ""
arr = [str(x) for x in numbers]
arr.sort(key = cmp_to_key(lambda x,y:int(x+y)-int(y+x)))
return int("".join(arr))
numbers = [3,32,321]
print(PrintMinNumber(numbers))
注意：上述代码基于python3实现，python3中sort()方法与python2中不一样，区别见python中sort函数;python2实现如下：
class Solution:
def PrintMinNumber(self, numbers):
if not len(numbers):
return ""
arr = [str(x) for x in numbers]
arr.sort(lambda x,y:cmp(x+y,y+x))
return int("".join(arr))
33. 丑数
题目描述
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
思路
因为丑数只包含质因子2，3，5；因此我们只需将2，3，5两两相乘，并将相乘的结果再与2，3，5相乘，这些乘法结果都是丑数。关键问题就是如何按从小到大的顺序写出丑数，我们可以这样做，每次都用2，3，5来乘结果res中的数，每次只选择最小的数加入res中，具体做法见程序。
class Solution:
def GetUglyNumber_Solution(self, index):
# write code here
if index <=0:
return 0
res = [1]
a,b,c = 0, 0, 0
while len(res)<index:
minNext = min(res[a]*2, res[b]*3, res[c]*5)
res.append(minNext)
while res[a]*2 <= minNext:
a += 1
while res[b]*3 <= minNext:
b += 1
while res[c]*5 <= minNext:
c += 1
return res[-1]
34. 第一个只出现一次的字符
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.（从0开始计数）
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
for x in s:
if s.count(x)==1:
return s.index(x)
return -1
35. 数组中的逆序对[**][****]
题目描述
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
思路
使用二分法；详见剑指offer学习
class Solution:
def InversePairs(self, data):
# write code here
if len(data)>1:
mid = len(data)//2
left = data[:mid]
right = data[mid:]
left_count = self.InversePairs(left)%1000000007
right_count = self.InversePairs(right)%1000000007
i , j, k, count = len(left)-1, len(right)-1, len(data)-1, 0
while i>=0 and j>=0:
if left[i] <= right[j]:
data[k] = right[j]
j -= 1
k -= 1
else:
data[k] = left[i]
count += (j+1)
i -= 1
k -= 1
if i>=0:
data[:i+1] = left[:i+1]
if j >= 0:
data[:j+1] = right[:j+1]
return (count + left_count + right_count)%1000000007
else:
return 0
36. 两个链表的第一个公共节点
题目描述
输入两个链表，找出它们的第一个公共结点。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）
思路
设置两个指针，一个从headA开始遍历，遍历完headA再遍历headB，另一个从headB开始遍历，遍历完headB再遍历headA，如果有交点，两个指针会同时遍历到交点处。
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
ptr1 = pHead1
ptr2 = pHead2
while ptr1 != ptr2:
if ptr1 == None:
ptr1 = pHead2
else:
ptr1 = ptr1.next
if ptr2 == None:
ptr2 = pHead1
else:
ptr2 = ptr2.next
return ptr2
37. 数字在排序数组中的次数
统计一个数字在排序数组中出现的次数
思路1：暴力法
class Solution:
def GetNumberOfK(self, data, k):
# write code here
count = 0
for i in range(len(data)):
if data[i] == k:
count += 1
return count
思路2：双指针法
class Solution:
def GetNumberOfK(self, data, k):
if not data:
return 0
# write code here
i, j = 0, len(data)-1
while i < j and data[i]!=data[j]:
if data[i]<k:
i += 1
if data[j]>k:
j -= 1
if data[i] != k:
return 0
else:
return j-i+1
38. 二叉树的深度
题目描述
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
思路1：递归
class Solution:
def TreeDepth(self, pRoot):
# write code here
res = []
self.deep(pRoot, 0, res)
return max(res)
def deep(self, root, count, res):
if root != None:
count += 1
self.deep(root.left, count, res)
self.deep(root.right, count, res)
if root == None:
res.append(count)
思路2
class Solution:
def TreeDepth(self, pRoot):
# write code here
if pRoot == None:
return 0
else:
return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right))+1
39.平衡二叉树[Done]
题目描述
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树
class Solution:
def IsBalanced_Solution(self, pRoot):
# write code her
if pRoot == None:
return True
else:
if abs(self.height(pRoot.left)-self.height(pRoot.right))>1:
return False
return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
def height(self, root):
if root == None:
return 0
else:
return max(self.height(root.left), self.height(root.right))+1
40. 数组中只出现一次的数字
题目描述
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
方法1：暴力法
class Solution:
# 返回[a,b] 其中ab是出现一次的两个数字
def FindNumsAppearOnce(self, array):
# write code here
res = []
for x in set(array):
if array.count(x) == 1:
res.append(x)
return res
方法2
这个问题可以可以使用用异或的性质解决。异或的性质：对于整数a,有
（1） a^a=0
（2）a^0=a
（2）a^b^c=a^(b^c)=(a^c)^b
利用以上的性质，上面的题目的解法为：
(1)对于出现两次的元素，使用“异或”操作后结果肯定为0，那么我们就可以遍历一遍数组，对所有元素使用异或操作，那么得到的结果就是两个出现一次的元素的异或结果
(2)因为这两个元素不相等，所以异或的结果肯定不是0，也就是可以再异或的结果中找到1位不为0的位，例如异或结果的最后一位不为0。
(3)这样我们就可以最后一位将原数组元素分为两组，一组该位全为1，另一组该位全为0。
(4)再次遍历原数组，最后一位为0的一起异或，最后一位为1的一起异或，两组异或的结果分别对应着两个结果。
# -*- coding:utf-8 -*-
class Solution:
# 返回[a,b] 其中ab是出现一次的两个数字
def FindNumsAppearOnce(self, array):
# write code here
res = 0
for i in array:
res = res^i
flag = 1
while flag & res == 0:
flag = flag<< 1
res1 = 0
res2 = 0
for x in array:
if flag&x == 0:
res1 = res1^x
else:
res2 = res2^x
return [res1, res2]
41. 和为s的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
思路
使用双指针，初始化 i= 1， j = 2；然后当将 i 到 j 的数求和，若小于 tsum, 将 j加1，直到大于 tsum ，然后改变 i 指针值，将其加1；
class Solution:
def FindContinuousSequence(self, tsum):
# write code here
i = 1
j = 2
cursum = i + j
res = []
while i <= tsum//2:
if cursum == tsum:
res.append(range(i, j+1))
j += 1
cursum += j
elif cursum > tsum :
cursum -= i
i += 1
else:
j += 1
cursum += j
return res
42. 和为S的两个数字[Done]
输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
思路1
暴力法： O ( N 2 ) O(N^2) O(N2)
class Solution:
def FindNumbersWithSum(self, array, tsum):
# write code here
result = []
maxsum = float("inf")
for i in range(len(array)):
for j in range(i, len(array)):
if array[i] + array[j] == tsum:
if array[i]*array[j] < maxsum:
maxsum = array[i]*array[j]
result = [array[i], array[j]]
return result
思路2： 双指针法
class Solution:
def FindNumbersWithSum(self, array, tsum):
# write code here
i = 0
j = len(array)-1
while i<j:
if array[i]+array[j] < tsum:
i += 1
elif array[i]+array[j] > tsum:
j -= 1
else:
return [array[i], array[j]]
return []
43. 左旋转字符串[Done]
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
class Solution:
def LeftRotateString(self, s, n):
if not s:
return s
# write code here
slen = len(s)
temp = n%slen
if temp == 0:
return s
else:
return s[temp:]+s[:temp]
44. 反转字符串[Done]
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对翻转这些单词顺序可不在行，你能帮助他么？
class Solution:
def ReverseSentence(self, s):
if s is None or len(s) == 0:
return s
stack = []
for i in s.split(' '): #split()通过指定分隔符对字符串进行切片
stack.append(i)
res = ""
while len(stack) > 0:
res += stack.pop() + " "
res = res[:-1]
return res
注意：
也可以用堆栈，先逐个入栈，再逐个出栈
45. 扑克牌顺子
一副扑克牌,里面有2个大王，2个小王，从中随机抽出5张牌，如果牌能组成顺子就输出true，否则就输出false。为了方便起见，大小王是0，大小王可以当作任何数字。其中J,Q,K,A分别用11， 12， 13， 1 表示
思路：
1、将数组排序 ；2、统计数组中0的个数，即判断大小王的个数；3、统计数组中相邻数字之间的空缺总数，如果空缺数小于等于大小王的个数，可以组成顺子，否则不行。如果数组中出现了对子，那么一定是不可以组成顺子的。
class Solution:
def IsContinuous(self, numbers):
if not numbers:
return False
# write code here
numbers.sort()
zero_count = numbers.count(0)
numbers = numbers[zero_count:]
count = 0
for i in range(len(numbers)-1):
if numbers[i+1]==numbers[i]:
return False
count += (numbers[i+1]-numbers[i]-1)
if count <= zero_count:
return True
else:
return False
46.圆圈中剩下的数
让小朋友们围成一个大圈。然后，他随机指定一个数m，让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列，不再回到圈中，从他的下一个小朋友开始，继续0…m-1报数…这样下去…直到剩下最后一个小朋友获胜，获胜的小朋友编号多少？(注：小朋友的编号是从0到n-1)
class Solution:
def LastRemaining_Solution(self, n, m):
# write code here
if not n or not m:
return -1
res = range(n)
i = 0
while len(res)>1:
i = (m+i-1)%len(res)
res.pop(i)
return res[0]
47. 求1+2+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
短路求值
class Solution:
def __init__(self):
self.result = 0
def Sum_Solution(self, n):
self.add(n)
return self.result
def add(self, x):
self.result += x
return x-1 and self.add(x-1)
48. 不用加减乘除做加法
写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
思路
（1）不考虑进位对每一位相加，0加0、1加1的结果都是0，1加0、0加1的结果都是1。这和异或运算相同。
（2）考虑进位，只有1加1的时候产生进位。 位与运算只有两个数都是1的时候结果为1。考虑成两个数都做位与运算，然后向左移一位。
（3）相加的过程依然重复前面两步，直到不产生进位为止。
java程序
public class Solution {
public int Add(int num1,int num2) {
while(num2 != 0){
int temp = num2^num1;
int flag = (num2&num1)<<1;
num1 = temp;
num2 = flag;
}
return num1;
}
}
python程序
在进行负数的按位加法时，有可能发生在最高位还要向前进一位的情形，正常来说，这种进位因为超出了一个int可以表示的最大位数，应该舍去才能得到正确的结果。因此，对于Java，c，c++这样写是正确的。而对于Python，却有点不同。
class Solution:
def Add(self, num1, num2):
while num2!=0:
sum = num1^num2
carry = 0xFFFFFFFF&((num1&num2)<<1)
carry = -(~(carry-1)&0xFFFFFFFF) if carry > 0x7fffffff else carry
num1 = sum
num2 = carry
return num1
49.字符串转换成整数
将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
class Solution:
def StrToInt(self, s):
# write code here
if not s:
return 0
res = 0
flag = 1
if s[0] == "-":
flag = -1
s = s[1:]
elif s[0] == "+":
s = s[1:]
for x in s:
if x>="0" and x<="9":
res = res*10+(ord(x)-ord("0"))
else:
return 0
return res*flag
50.数组中重复的数字
题目描述
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
思路1：暴力法
class Solution:
# 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
# 函数返回True/False
def duplicate(self, numbers, duplication):
# write code here
for i in range(len(numbers)):
if numbers[i] in numbers[i+1:]:
duplication[0] = numbers[i]
return True
else:
return False
思路2：
注意到数组中的数字都在0~n-1范围内，如果这个数组中没有重复的数字，那么当数组排序后数字i在下标i的位置，由于数组中有重复的数字，有些位置可能存在多个数字，同时有些位置可能没有数字。遍历数组，当扫描到下标为i 的数字m时，首先看这个数字是否等于i，如果是，继续扫描，如果不是，拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字，如果不相等，就交换两个数字。继续比较
class Solution:
# 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
# 函数返回True/False
def duplicate(self, numbers, duplication):
# write code here
for i in range(len(numbers)):
while numbers[i] != i:
m = numbers[i]
if numbers[m] == m:
duplication[0] = m
return True
else:
numbers[i], numbers[m] = numbers[m], m
return False
51. 构建乘积数组
给定一个数组 A [ 0 , 1 , . . . , n − 1 ] A[0,1,...,n-1] A[0,1,...,n−1],请构建一个数组 B [ 0 , 1 , . . . , n − 1 ] B[0,1,...,n-1] B[0,1,...,n−1],其中B中的元素 B [ i ] = A [ 0 ] ∗ A [ 1 ] ∗ . . . ∗ A [ i − 1 ] ∗ A [ i + 1 ] ∗ . . . ∗ A [ n − 1 ] B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1] B[i]=A[0]∗A[1]∗...∗A[i−1]∗A[i+1]∗...∗A[n−1]。不能使用除法。（注意：规定 B [ 0 ] = A [ 1 ] ∗ A [ 2 ] ∗ . . . ∗ A [ n − 1 ] ， B [ n − 1 ] = A [ 0 ] ∗ A [ 1 ] ∗ . . . ∗ A [ n − 2 ] B[0] = A[1] * A[2] * ... * A[n-1]，B[n-1] = A[0] * A[1] * ... * A[n-2] B[0]=A[1]∗A[2]∗...∗A[n−1]，B[n−1]=A[0]∗A[1]∗...∗A[n−2];）
class Solution:
def multiply(self, A):
# write code here
C, D = [], []
for i in range(len(A)):
if i == 0:
C.append(1)
else:
C.append(C[i-1]*A[i-1])
for i in range(len(A)):
if i == 0:
D.append(1)
else:
D.append(D[i-1]*A[len(A)-i])
result = []
D = D[::-1]
for i in range(len(A)):
result.append(C[i]*D[i])
return result
52. 正则表达式匹配
请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配
动态规划
class Solution:
# s, pattern都是字符串
def match(self, s, pattern):
# write code here
p = pattern
dp = [[False]*(len(pattern)+1) for _ in range(len(s)+1)]
dp[0][0] = True
for j in range(1, len(pattern)+1):
if p[j-1] == "*" and j>=2:
dp[0][j] = dp[0][j-2]
elif j == 1 and p[j-1]=="*":
dp[0][j] = True
for i in range(1, len(s)+1):
for j in range(1, len(pattern)+1):
if s[i-1]==p[j-1] or p[j-1]==".":
dp[i][j] = dp[i-1][j-1]
elif p[j-1] == "*" and (s[i-1] == p[j-2] or p[j-2]=="."):
dp[i][j] = dp[i-1][j-1] or dp[i-1][j] or dp[i][j-2]
else :
dp[i][j] = dp[i][j-2]
return dp[-1][-1]
53. 表示数值的字符串
题目描述
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
思路
如果遍历到e或E，那么之前不能有e或E，并且e或E不能在末尾；
如果遍历到小数点,那么之前不能有小数点，并且之前不能有e或E；
如果遍历到正负号，那么如果之前有正负号，只能够出现在e或E的后面，如果之前没符号，那么符号只能出现在第一位，或者出现在e或E的后面；
如果遍历到不是上面所有的符号和0~9，返回False
# -*- coding:utf-8 -*-
class Solution:
# s字符串
def isNumeric(self, s):
# write code here
hassign = False
hase = False
hasdot = False
for i in range(len(s)):
if s[i] == "+" or s[i]=="-":
if hassign and s[i-1]!="e" and s[i-1]!="E":
return False
if not hassign and s[i-1]!="e" and s[i-1]!="E" and i!=0:
return False
hassign = True
elif s[i] == "e" or s[i] == "E":
if hase or i == (len(s)-1):
return False
hase = True
elif s[i] == ".":
if hasdot or hase:
return False
hasdot = True
elif s[i]<"0" or s[i]>"9":
return False
return True
54. 字符流中第一个不重复的字符
题目描述
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
用例:
"google"
对应输出应该为:
"ggg#ll"
class Solution:
# 返回对应char
def __init__(self):
self.s = ""
self.dic = {
}
def FirstAppearingOnce(self):
# 返回结果
for x in self.s:
if self.dic[x]== 1:
return x
return "#"
def Insert(self, char):
# 读入数据
for x in char:
self.s = self.s + x
if x in self.dic:
self.dic[x] = self.dic[x]+1
else:
self.dic[x] = 1
55. 链表中环的入口节点
题目描述
给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
class Solution:
def EntryNodeOfLoop(self, pHead):
# write code here
ptr = pHead
nodes = []
while ptr != None:
if ptr in nodes:
return ptr
else:
nodes.append(ptr)
ptr = ptr.next
return None
思路2：
设置快慢指针，都从链表头出发，快指针每次走两步，慢指针一次走一步，假如有环，一定相遇于环中某点(结论1)。接着让两个指针分别从相遇点和链表头出发，两者都改为每次走一步，最终相遇于环入口(结论2)。以下是两个结论证明：
两个结论：
1、设置快慢指针，假如有环，他们最后一定相遇。
2、两个指针分别从链表头和相遇点继续出发，每次走一步，最后一定相遇与环入口。
证明结论1：设置快慢指针fast和low，fast每次走两步，low每次走一步。假如有环，两者一定会相遇（因为low一旦进环，可看作fast在后面追赶low的过程，每次两者都接近一步，最后一定能追上）。
证明结论2：
设：
链表头到环入口长度为–a
环入口到相遇点长度为–b
相遇点到环入口长度为–c
则：相遇时
快指针路程=a+(b+c)k+b ，k>=1 其中b+c为环的长度，k为绕环的圈数（k>=1,即最少一圈，不能是0圈，不然和慢指针走的一样长，矛盾）。
慢指针路程=a+b
快指针走的路程是慢指针的两倍，所以：
（a+b）*2=a+(b+c)k+b
化简可得：
a=(k-1)(b+c)+c 这个式子的意思是： 链表头到环入口的距离=相遇点到环入口的距离+（k-1）圈环长度。其中k>=1,所以k-1>=0圈。所以两个指针分别从链表头和相遇点出发，最后一定相遇于环入口。
class Solution:
def EntryNodeOfLoop(self, pHead):
if pHead == None or pHead.next == None or pHead.next.next == None:
return None
low = pHead.next
fast = pHead.next.next
while low != fast:
if fast.next == None or fast.next.next == None:
return None
low = low.next
fast = fast.next.next
fast = pHead
while low != fast:
low = low.next
fast = fast.next
return fast
56. 删除列表中的重复节点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
class Solution:
def deleteDuplication(self, pHead):
# write code here
first = ListNode(-1)
first.next = pHead
pre = first
cur = pHead
while cur:
while cur.next and cur.next.val == cur.val:
cur = cur.next
# 判读中间有无跳过重复值
if pre.next == cur:
pre = pre.next
# 若有重复值则跳过
else:
pre.next = cur.next
cur = cur.next
return first.next
57. 二叉树下一个节点
题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：
- 如果该节点有右子树，那么它的下一个节点就是它的右子树的最左侧子节点；
- 如果该节点没有右子树且是父节点的左子树，那么下一节点就是父节点；
- 如果该节点没有右子树且是父节点的右子树，比如i节点，那么我们往上找父节点，找到一个节点满足： 它是它的父节点的左子树的节点。
class Solution:
# class TreeLinkNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
# self.next = None
def GetNext(self, pNode):
# write code here
if not pNode:
return None
# 该节点有右子树
if pNode.right != None:
temp = pNode.right
while temp.left != None:
temp = temp.left
return temp
# 没有右子树
else:
while pNode.next:
temp = pNode.next
# 该节点是父节点的左子树
if temp.left == pNode:
# 返回父节点
return temp
pNode = temp
return None
58. 对称二叉树
题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
递归：
class Solution:
def isSymmetrical(self, pRoot):
# write code here
if not pRoot:
return True
else:
return self.helper(pRoot.left, pRoot.right)
def helper(self, left, right):
if left == None and right == None:
return True
elif left == None or right == None or left.val != right.val:
return False
else:
return self.helper(left.left, right.right) and self.helper(left.right, right.left)
59.按之字形顺序打印二叉树
题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
class Solution:
def Print(self, pRoot):
if not pRoot:
return []
# write code here
nodes, flag, result = [[pRoot]], True, []
while nodes:
node = nodes.pop()
flag = not flag
res, temp = [], []
while node:
no = node.pop()
res.append(no.val)
if flag:
if no.right:
temp.append(no.right)
if no.left:
temp.append(no.left)
else:
if no.left:
temp.append(no.left)
if no.right:
temp.append(no.right)
if temp:
nodes.insert(0, temp)
result.append(res)
return result
way2
每次节点还是按从左到右加入，在加入结果时进行判断是否需要翻转
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Print(self, pRoot):
# write code here
if not pRoot:
return []
all_nodes = [[pRoot]]
flag = False
result = []
while all_nodes:
node_list = all_nodes.pop(0)
nodes = []
res = []
for node in node_list:
if node.left:
nodes.append(node.left)
if node.right:
nodes.append(node.right)
res.append(node.val)
if nodes:
all_nodes.append(nodes)
if not flag:
result.append(res)
else:
result.append(res[::-1])
flag = not flag
return result
60. 将二叉树打印成多行
题目描述
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
注意：
本题和上一题很相似，但是两个题目用了不一样的方法，两个方法都可用于两个题目
class Solution:
# 返回二维列表[[1,2],[4,5]]
def Print(self, pRoot):
# write code here
if not pRoot:
return []
nodes, result = [pRoot], []
while nodes:
res = []
for i in range(len(nodes)):
node = nodes.pop()
res.append(node.val)
if node.left:
nodes.insert(0, node.left)
if node.right:
nodes.insert(0, node.right)
result.append(res)
return result
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回二维列表[[1,2],[4,5]]
def Print(self, pRoot):
# write code here
if not pRoot:
return []
result = []
all_nodes = [[pRoot]]
while all_nodes:
res, temp_node = [], []
nodes_list = all_nodes.pop(0)
for node in nodes_list:
res.append(node.val)
if node.left:
temp_node.append(node.left)
if node.right:
temp_node.append(node.right)
if temp_node:
all_nodes.append(temp_node)
result.append(res)
return result
61. 序列化二叉树
题目描述
请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树
注意：题目描述不清楚，题目的意思是先将树序列化，然后再恢复成树，最后返回的是恢复的树的根，因此在第一步将树序列化的时候可以将树序列化成字符串也可以列表。
思路：
使用前序遍历序列化，然后用前序遍历恢复，因为前序遍历根在最前面，比较好返回
class Solution:
def __init__(self):
self.temp = []
def Serialize(self, root):
# write code here
if root == None:
return "# "
else:
return str(root.val)+" "+self.Serialize(root.left)+self.Serialize(root.right)
return self.result
def Deserialize(self, s):
# write code here
temp = s.strip().split(" ")
return self.helper(temp)
def helper(self, temp):
if not temp:
return
char = temp.pop(0)
if char == "#":
return None
root = TreeNode(int(char))
root.left = self.helper(temp)
root.right = self.helper(temp)
return root
62. 二叉搜索树的第K个节点
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
思路：
中序遍历二叉搜索树，结果就是从小到大排序，然后返回第K个即可
class Solution:
# 返回对应节点TreeNode
def KthNode(self, pRoot, k):
# write code here
if k==0:
return None
res = []
self.mid(pRoot, res)
if k>len(res):
return None
return res[k-1]
def mid(self, root, res):
if root != None:
self.mid(root.left, res)
res.append(root)
self.mid(root.right, res)
63. 数据流中的中位数
题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
思路：
每接受一个数进行插入排序，然后对排序后的列表求中位数;注意python2.x和python3.x中的/操作符区别。
class Solution:
def __init__(self):
self.res = []
def Insert(self, num):
# write code here
if self.res == []:
self.res.append(num)
else:
i = len(self.res)-1
while i>=0:
if self.res[i]>num:
i -= 1
else:
break
self.res.insert(i+1, num)
def GetMedian(self, data):
# write code here
length = len(self.res)
if length%2 == 0:
return (self.res[length//2]+self.res[(length//2)-1])/2.0
else:
return self.res[length//2]
64. 滑动窗口中的最大值
题目描述
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个：{[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}，{2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}，{2,3,4,2,[6,2,5],1}，{2,3,4,2,6,[2,5,1]}。
思路一：求每次窗口的最大值，时间复杂度O(n*size)
class Solution:
def maxInWindows(self, num, size):
# write code here
if size ==0:
return []
res = []
i, j = 0, size
while j<=len(num):
res.append(max(num[i:j]))
i += 1
j += 1
return res
思路2：
用一个双端队列，队列第一个位置保存当前窗口的最大值，当窗口滑动一次
1.判断当前最大值是否过期，即当前最大值是否属于当前窗口中的数
2.新增加的值从队尾开始比较，把所有比他小的值丢掉（这样后面加入第二大的值，当最大值过期后，第二大的值成为最大值）
注意：queue中保存的是索引
class Solution:
def maxInWindows(self, num, size):
# write code here
if not num or not size:
return []
queue = []
res = []
i = 0
while i < len(num):
# 判断最大值是否过期
if len(queue)>0 and i-size+1>queue[0]:
queue.pop(0)
# 将小于当前值的元素全都pop掉
while len(queue)>0 and num[queue[-1]]<num[i]:
queue.pop()
queue.append(i)
# 加入前两个元素时不需要保存结果
if i-size+1>=0:
res.append(num[queue[0]])
i += 1
return res
65. 矩阵中的路径
题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 [ a b c e s f c s a d e e ] \left[\begin{array}{llll}a & b & c & e \\ s & f & c & s \\ a & d & e & e\end{array}\right] ⎣⎡asabfdcceese⎦⎤ 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
回溯算法
class Solution:
def hasPath(self, matrix, rows, cols, path):
if path == "":
return True
# write code here
flag = [[True]*cols for _ in range(rows)]
# 此处循环定义起点
for i in range(rows):
for j in range(cols):
if matrix[i*cols+j] == path[0]:
flag[i][j] = False
if self.go(i, j, rows, cols, path[1:], matrix, flag[:]):
return True
flag[i][j]= True
# 遍历所有起点都没有成功，返回False
return False
def go(self, r, c, rows, cols, path, matrix, flag):
if path == "":
return True
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]
# 定义前进方向
for k in range(4):
x = r+dx[k]
y = c+dy[k]
if x>=0 and x<rows and y>=0 and y<cols and matrix[x*cols+y]==path[0] and flag[x][y]:
flag[x][y]=False
if self.go(x, y, rows, cols, path[1:], matrix, flag[:]):
return True
flag[x][y]=True
# 四个方向都不能走通，返回False
return False
66.机器人运动范围
题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
注意：本题并不是求最长路径，而是求出可到达的方格个数
class Solution:
def __init__(self):
self.count = 0
def movingCount(self, threshold, rows, cols):
flag = [[True]*cols for _ in range(rows)]
self.go(0, 0, threshold, rows, cols, flag)
return self.count
# write code here
def go(self, x, y, threshold, rows, cols, flag):
if x>=0 and y>=0 and x<rows and y<cols and sum(map(int, str(x)))+sum(map(int, str(y)))<=threshold and flag[x][y]:
flag[x][y] = False
self.count += 1
self.go(x+1, y, threshold, rows, cols, flag)
self.go(x-1, y, threshold, rows, cols, flag)
self.go(x, y+1, threshold, rows, cols, flag)
self.go(x, y-1, threshold, rows, cols, flag)
67. 剪绳子
题目描述
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],...,k[m]。请问k[0]*k[1]*...*k[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
思路：
由经验得知，乘积最大往往在有很多段都集中在一个较大的数时，因此，将每段的长度从1遍历到num-1;然后计算出这种长度有多少段，最后余数另成一段
class Solution:
def cutRope(self, number):
# write code here
if number == 2:
return 1
if number == 3:
return 2
maxnum = 0
# i表示长度
for i in range(1, number):
# 计算长度为i的段数
x = number//i
# 计算余数
y = number-x*i
if y!=0:
maxnum = max(maxnum,i**x*y)
else:
maxnum = max(maxnum, i**x)
return maxnum
参考
[1]. 牛客网 | 挑战剑指offer
[2].剑指offer python版