文章目录
- 1. 二维数组中的查找
- 2. 替换空格
- 3. 从尾到头打印一个链表
- 4. 重建二叉树
- 5. 用两个栈实现队列
- 6. 旋转数组的最小数字
- 7. 斐波那契数列
- 8. 跳台阶
- 9. 变态跳台阶
- 10. 矩形覆盖
- 11. 二进制中1的个数
- 12. 数值的整数次方
- 13. 调整数组顺序，使奇数在偶数前面
- 14. 链表中倒数第k个节点
- 15. 反转链表
- 16. 合并两个排序链表
- 17. 树的子结构
- 18. 二叉树的镜像
- 19. 顺时针打印矩阵
- 20. 包含min函数的栈
- 21. 栈的压入和弹出
- 22. 从上往下打印二叉树
- 23. 二叉搜索树的后序遍历
- 24. 二叉树中和为某一值的路径
- 25. 复杂链表的复制
- 26. 二叉搜索树和双向链表
- 27. 字符串的排列
- 28. 数组中出现超过一次的数字
- 29.最小的k个数
- 30. 连续子数组的最大和
- 31. 整数中出现1的次数
- 32. 把数组排成最小的数
- 33. 丑数
- 34. 第一个只出现一次的字符
- 35. 数组中的逆序对
- 36. 两个链表的第一个公共节点
- 37. 数字在排序数组中出现的次数
- 38. 二叉树的深度
- 39. 平衡二叉树
- 40. 数组中只出现一次的数字
- 41. 和为s的连续正数序列
- 42. 和为S的两个数
- 43. 左旋转字符串
- 44. 反转单词顺序
- 45. 扑克牌顺子
- 46. 圆圈中最后剩下的数
- 47. 求1+2+3+…+n
- 48. 不用加减乘除做加法
- 49. 把字符串转换成整数
- 50.表示数字的字符串
- 51. 字符流中第一个不重复的字符
- 52. 删除链表中的重复节点
- 53. 二叉树的下一个节点
- 54. 对称的二叉树
- 55.按之字行顺序打印二叉树
- 56. 把二叉树打印成多行
- 57. 序列化二叉树
- 58. 二叉搜索数的第k个节点
- 59. 数据流中的中位数
- 60. 滑动窗口的最大值
- 61. 机器人的运动范围
1. 二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
# -*- coding:utf-8 -*-
class Solution:
# array 二维列表
def Find(self, target, array):
# write code here
if not array:
return False
m,n=len(array),len(array[0])
i,j=0,n-1
while i<m and j>=0:
if array[i][j]==target:
return True
if array[i][j]<target:
i+=1
else:
j-=1
return False2. 替换空格
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
# -*- coding:utf-8 -*-
class Solution:
# s 源字符串
def replaceSpace(self, s):
# write code here
if not s:
return ""
res=''
for num in s:
if num.isspace():
res+='%20'
else:
res+=num
return res3. 从尾到头打印一个链表
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
class Solution:
# 返回从尾部到头部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
res=[]
if not listNode:
return res
while listNode:
res.append(listNode.val)
listNode=listNode.next
return res[::-1]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
root_val=pre.pop(0)
index=tin.index(root_val)
root=TreeNode(root_val)
root.left=self.reConstructBinaryTree(pre[:index],tin[:index])
root.right=self.reConstructBinaryTree(pre[index:],tin[index+1:])
return root5. 用两个栈实现队列
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.stack1=[]
self.stack2=[]
def push(self, node):
self.stack1.append(node)
# write code here
def pop(self):
# return xx
if len(self.stack1)==0 and len(self.stack2)==0:
return None
while self.stack2:
res=self.stack2.pop(0)
return res
while self.stack1 and not self.stack2:
node=self.stack1.pop(0)
self.stack2.append(node)
res=self.stack2.pop(0)
return res6. 旋转数组的最小数字
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
# -*- coding:utf-8 -*-
class Solution:
def minNumberInRotateArray(self, rotateArray):
# write code here
left,right=0,len(rotateArray)-1
while left<right:
mid=left+(right-left)//2
if rotateArray[mid]<rotateArray[mid-1]:
return rotateArray[mid]
if rotateArray[mid]>rotateArray[right]:
left=mid+1
else:
right=mid-1
return rotateArray[left]7. 斐波那契数列
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。 n<=39
# -*- coding:utf-8 -*-
class Solution:
def Fibonacci(self, n):
if n==0:
return 0
# write code here
elif n<=2:
return 1
res=[1,1]
for i in range(n-2):
res.append(res[-1]+res[-2])
return res[-1]8. 跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
# -*- coding:utf-8 -*-
class Solution:
def jumpFloor(self, number):
# write code here
if number==0:
return None
elif number<=2:
return number
res=[1,2]
for i in range(number-2):
res.append(res[-1]+res[-2])
return res[-1]9. 变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
# -*- coding:utf-8 -*-
class Solution:
def jumpFloorII(self, number):
# write code here
return 2**(number-1)10. 矩形覆盖
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
# -*- coding:utf-8 -*-
class Solution:
def rectCover(self, number):
# write code here
if number==0:
return 0
elif number<=2:
return number
res=[1,2]
for i in range(number-2):
res.append(res[-1]+res[-2])
return res[-1]11. 二进制中1的个数
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
# -*- coding:utf-8 -*-
class Solution:
def NumberOf1(self, n):
# write code here
count=0
if n<0:
n=n&0xffffffff
while n:
n=(n-1)&n
count+=1
return count12. 数值的整数次方
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
保证base和exponent不同时为0
# -*- coding:utf-8 -*-
class Solution:
def Power(self, base, exponent):
# write code here
if exponent==0:
return 1
res,exp,flag=1,1,1
if exponent<0:
flag=-1
exponent=-exponent
while exponent:
if exponent%2:
res=res*(base**(exp))
exponent=exponent>>1
exp=exp*2
return res if flag==1 else 1.0/res13. 调整数组顺序，使奇数在偶数前面
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
# -*- coding:utf-8 -*-
class Solution:
def reOrderArray(self, array):
# write code here
res=[]
odd=[item for item in array if item%2]
even=[item for item in array if not item%2]
res=odd+even
return res14. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个结点。
class Solution:
def FindKthToTail(self, head, k):
# write code here
if not head:
return None
l1,l2=head,head
for i in range(k):
if l1:
l1=l1.next
else:
l1=head
while l1:
l1=l1.next
l2=l2.next
return l215. 反转链表
输入一个链表，反转链表后，输出新链表的表头。
class Solution:
# 返回ListNode
def ReverseList(self, pHead):
# write code here
if not pHead or not pHead.next:
return pHead
pre=None
while pHead:
tmp=pHead.next
pHead.next=pre
pre=pHead
pHead=tmp
return pre16. 合并两个排序链表
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
class Solution:
# 返回合并后列表
def Merge(self, pHead1, pHead2):
# write code here
if not pHead1:
return pHead2
if not pHead2:
return pHead1
if pHead1.val<pHead2.val:
pHead1.next=self.Merge(pHead1.next,pHead2)
return pHead1
else:
pHead2.next=self.Merge(pHead1,pHead2.next)
return pHead2 17. 树的子结构
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
class Solution:
def HasSubtree(self, pRoot1, pRoot2):
# write code here
if not pRoot1:
return False
else return self.isSame(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)
def isSame(self,s,t):
if s and t:
return s.val==t.val and self.isSame(s.left,t.left) and self.isSame(s.right,t.right)
elif s==t:
return True
else:
return False18. 二叉树的镜像
操作给定的二叉树，将其变换为源二叉树的镜像。
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
# write code here
if not root or (not root.left and not root.right):
return root
self.Mirror(root.left)
self.Mirror(root.right)
root.left,root.right=root.right,root.left
19. 顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
# -*- coding:utf-8 -*-
class Solution:
# matrix类型为二维列表，需要返回列表
def printMatrix(self, matrix):
if matrix is None or matrix == []:
return []
row = len(matrix)
column = len(matrix[0])
res = []
i = r_count = c_count = 0#r_count和c_count用来记录当前已打印过的行数和列数
j = -1
while r_count < row and c_count < column:
n = column - c_count
if n <= 0:#加上这个判断是为了n*1或1*n的矩阵出现，这类矩阵不需要进行四次方向的打印，只需进行两次，如果不加这个判断会打印出重复元素
break
while n > 0:
j += 1
n -= 1
res.append(matrix[i][j])
r_count += 1
n = row - r_count
if n <= 0:
break
while n > 0:
i += 1
n -= 1
res.append(matrix[i][j])
c_count += 1
n = column - c_count
if n <= 0:
break
while n > 0:
j -= 1
n -= 1
res.append(matrix[i][j])
r_count += 1
n = row - r_count
if n <= 0:
break
while n > 0:
i -= 1
n -= 1
res.append(matrix[i][j])
c_count += 1
return res20. 包含min函数的栈
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
class Solution:
def __init__(self):
self.Stack = []
self.minStack = []
def push(self, node):
# write code here
self.Stack.append(node)
if self.minStack == [] or node < self.min():
self.minStack.append(node)
else:
tmp = self.min()
self.minStack.append(tmp)
def pop(self):
# write code here
if self.Stack == [] or self.minStack == []:
return None
self.Stack.pop()
self.minStack.pop()
def top(self):
# write code here
return self.Stack[-1]
def min(self):
# write code here
return self.minStack[-1]l21. 栈的压入和弹出
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
class Solution:
def IsPopOrder(self, pushV, popV):
# write code here
if pushV == [] or popV == []:
return False
stack = []
for i in pushV:
stack.append(i)
if stack[-1] != popV[0]:
continue
else:
stack.pop()
popV.pop(0)
while len(stack) > 0 and stack[-1] == popV[0]:
stack.pop()
popV.pop(0)
if len(stack) == 0:
return True
else:
return False22. 从上往下打印二叉树
从上往下打印出二叉树的每个节点，同层节点从左至右打印。
class Solution:
# 返回从上到下每个节点值列表，例：[1,2,3]
def PrintFromTopToBottom(self, root):
# write code here
res=[]
if not root:
return res
queue=[]
queue.append(root)
while queue:
node=queue.pop(0)
res.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return res23. 二叉搜索树的后序遍历
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
class Solution:
def VerifySquenceOfBST(self, sequence):
# write code here
if not sequence:
return False
root=sequence[-1]
index=0
for i in range(len(sequence)-1):
index=i
if sequence[i]>root:
break
for j in range(index+1,len(sequence)-1):
if sequence[j]<root:
return False
left,right=True,True
if index>0 and index<len(sequence):
left=self.VerifySquenceOfBST(sequence[:index])
right=self.VerifySquenceOfBST(sequence[index:len(sequence)-1])
return left and right24. 二叉树中和为某一值的路径
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
class Solution:
# 返回二维列表，内部每个列表表示找到的路径
def FindPath(self, root, expectNumber):
# write code here
if not root:
return []
if not root.left and not root.right:
if root.val==expectNumber:
return [[root.val]]
else:
return []
a=self.FindPath(root.left,expectNumber-root.val)+self.FindPath(root.right,expectNumber-root.val)
return [[root.val]+i for i in a]25. 复杂链表的复制
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
class Solution:
# 返回 RandomListNode
def Clone(self, pHead):
# write code here
def copyNode(node,res):
if not node:
return None
if node in res:
return res[node]
copy=RandomListNode(node.label)
res[node]=copy
copy.next=copyNode(node.next,res)
copy.random=copyNode(node.random,res)
return copy
return copyNode(pHead,{})26. 二叉搜索树和双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
27. 字符串的排列
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。
class Solution:
def Permutation(self, ss):
# write code here
if not ss:
return []
s=list(ss)
s=set(s)
if len(s)==1:
return [ss]
res=[]
def back_trace(s,tmp):
if not s:
res.append(tmp)
return
for i in range(len(s)):
back_trace(nums[:i]+nums[i+1:],tmp+[nums[i]])
back_trace(nums,[])
return res28. 数组中出现超过一次的数字
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
class Solution:
def MoreThanHalfNum_Solution(self, numbers):
if not numbers:
return 0
num = numbers[0]
count = 1
for i in range(1, len(numbers)):
if numbers[i] == num:
count += 1
else:
count -= 1
if count == 0:
num = numbers[i]
count = 1
count = 0
for i in numbers:
if i == num:
count += 1
return num if count > len(numbers) / 2.0 else 029.最小的k个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。
class Solution:
def GetLeastNumbers_Solution(self, tinput, k):
# write code here
if len(tinput)<k:
return []
num=sorted(tinput)
return num[:k]30. 连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
class Solution:
def FindGreatestSumOfSubArray(self, array):
# write code here
if not array:
return 0
for i in range(1,len(array)):
array[i]=array[i]+max(array[i-1],0)
return max(array)31. 整数中出现1的次数
求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
class Solution:
def NumberOf1Between1AndN_Solution(self, n):
# write code here
if n<1: return 0
if n==1: return 1
last,ans,pos = 0,0,1
while(n):
num = n%10
n = n/10
ans += pos*n
if num>1:
ans+=pos
elif num==1:
ans+=(last+1)
last = last+num*pos
pos*=10
return ans32. 把数组排成最小的数
求出113的整数中1出现的次数,并算出1001300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。
33. 丑数
把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数。
34. 第一个只出现一次的字符
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）.
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
queue = []
memories = dict()
for idx,char in enumerate(s):
if char not in memories:
queue.append(idx)
memories[char]=0
memories[char]+=1
while(queue and memories[s[queue[0]]]>1):
queue.pop(0)
return queue[0] if queue else -135. 数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。
即输出P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字数据范围： 对于%50的数据,size<=10^4 对于%75的数据,size<=10^5 对于%100的数据,size<=2*10^5
class Solution:
def InversePairs(self, data):
# write code here
if len(data)<=0:
return 0
copy = []
for i in range(len(data)):
copy.append(data[i])
copy.sort()
count = 0
i = 0
while len(copy)>i:
count += data.index(copy[i])
data.remove(copy[i])
i +=1
return count36. 两个链表的第一个公共节点
输入两个链表，找出它们的第一个公共结点。
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
# write code here
p,q=pHead1,pHead2
while p!=q:
p=p.next if p else pHead2
q=q.next if q else pHead1
return p37. 数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。
class Solution:
def GetNumberOfK(self, data, k):
# write code here
def find_left_index(nums,target):
low,high=0,len(nums)-1
while low<high:
mid=low+(high-low)//2
if nums[mid]>target or target==nums[mid]:
high=mid
else:
low=mid+1
return low if nums and nums[low]==target else -1
def find_right_index(nums,target):
low,high=0,len(nums)-1
while low<high:
mid=low+(high-low)//2
if nums[mid]<target or target==nums[mid]:
low=mid
else:
high=mid-1
return low if nums and nums[low]==target else -1
res=find_right_index(data,k)-find_left_index(data,k)
return res38. 二叉树的深度
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)) + 139. 平衡二叉树
class Solution:
def IsBalanced_Solution(self, pRoot):
# write code here
if pRoot == None:
return True
if abs(self.getDepth(pRoot.left) - self.getDepth(pRoot.right)) > 1:
return False
else:
return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
def getDepth(self,pRoot):
if pRoot == None:
return 0
return max(self.getDepth(pRoot.left),self.getDepth(pRoot.right)) + 140. 数组中只出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
class Solution:
# 返回[a,b] 其中ab是出现一次的两个数字
def FindNumsAppearOnce(self, array):
# write code here
hashMap = {}
for i in array:
if str(i) in hashMap:
hashMap[str(i)] += 1
else:
hashMap[str(i)] = 1
res = []
for k in hashMap.keys():
if hashMap[k] == 1:
res.append(k)
return res41. 和为s的连续正数序列
小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
class Solution:
def FindContinuousSequence(self, tsum):
# write code here
if tsum < 3:
return []
small = 1
big = 2
middle = (tsum + 1) // 2
curSum = small + big
output = []
while small < middle:
if curSum == tsum:
output.append(list(range(small, big+1)))
while curSum > tsum and small < middle:
curSum -= small
small += 1
if curSum == tsum:
output.append(list(range(small, big+1)))
big += 1
curSum += big
return output42. 和为S的两个数
43. 左旋转字符串
汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
class Solution:
def LeftRotateString(self, s, n):
# write code here
str_s=str(s)+str(s)
#str_s=list(str_s)
return str_s[n,n+len(str(s))]44. 反转单词顺序
牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
class Solution:
def ReverseSentence(self, s):
# write code here
l = s.split(' ')
return ' '.join(l[::-1])45. 扑克牌顺子
LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
class Solution:
def IsContinuous(self, numbers):
# write code here
if len(numbers) == 0:
return False
# 对数字进行排序
numbers.sort()
# 大小王个数
numofking = numbers.count(0)
numoflack = 0
for i in range(numofking, len(numbers) - 1):
if numbers[i] == numbers[i + 1]:
return False
if numbers[i + 1] == numbers[i] + 1:
continue
else:
# 统计相邻数字之间的空缺数
numoflack += (numbers[i + 1] - numbers[i] - 1)
if numoflack <= numofking:
return True
else:
return False46. 圆圈中最后剩下的数
每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)`
class Solution:
def LastRemaining_Solution(self, n, m):
# write code here
if n < 1 or m < 1:
return -1
remainIndex = 0
for i in range(1, n+1):
remainIndex = (remainIndex + m) % i
return remainIndex47. 求1+2+3+…+n
求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）
class Solution:
def Sum_Solution(self, n):
# write code here
if n == 1:
return 1
return n + self.Sum_Solution(n-1)48. 不用加减乘除做加法
class Solution:
def Add(self, num1, num2):
# write code here
while num2 != 0:
temp = num1 ^ num2
num2 = (num1 & num2) << 1
num1 = temp & 0xFFFFFFFF#负数做处理
return num1 if num1 >> 31 == 0 else num1 - 4294967296 #考虑越界情况49. 把字符串转换成整数
将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
class Solution:
def StrToInt(self, s):
# write code here
import re #引入正则化模块
#正则化中^代表用^后面的开头，[-+]?表示[-+]可以出现，也可以不出现，\d匹配所有数字，\d+数字后面可以连接无数数字，但不能是其他东西，包括空格和字母
list_s = re.findall(r"^[-+]?\d+", str.strip()) #删除前，后空格。这样容易导致开始碰到字母就为空列表
#print(list_s)
if not list_s:
return 0 #字母开始列表是空的,直接返回0
else:
num =int(''.join(list_s)) #列表转化为字符串，然后转化为整数
if num >2**31 -1:
return 2**31 -1
elif num < -2**31:
return -2**31
else:
return num50.表示数字的字符串
import re
class Solution:
# s字符串
def isNumeric(self, s):
# write code here
return re.match(r"^[\+\-]?[0-9]*(\.[0-9]*)?([eE][\+\-]?[0-9]+)?$",s)51. 字符流中第一个不重复的字符
请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
class Solution:
# 返回对应char
def __init__(self):
self.adict = {}
self.alist = []
def FirstAppearingOnce(self):
while len(self.alist) > 0 and self.adict[self.alist[0]] == 2:
self.alist.pop(0)
if len(self.alist) == 0:
return '#'
else:
return self.alist[0]
def Insert(self, char):
if char not in self.adict.keys():
self.adict[char] = 1
self.alist.append(char)
elif self.adict[char]:
self.adict[char] = 252. 删除链表中的重复节点
class Solution:
def deleteDuplication(self, pHead):
# write code here
pos = pHead
ret = ListNode(-1)
tmp = ret
flag = False
while(pos and pos.next):
if pos.val == pos.next.val:
flag = True
pos.next = pos.next.next
else:
if flag:
flag = False
else:
tmp.next = ListNode(pos.val)
tmp = tmp.next
pos = pos.next
if pos and flag == False:
tmp.next = ListNode(pos.val)
return ret.next53. 二叉树的下一个节点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
class Solution:
def GetNext(self, pNode):
# write code here
if pNode == None:
return None
if pNode.right:
tmp = pNode.right
while(tmp.left):
tmp = tmp.left
return tmp
p = pNode.next
while(p and p.right==pNode):
pNode = p
p = p.next
return p54. 对称的二叉树
class Solution:
def isSymmetrical(self, pRoot):
# write code here
return self.selfIsSymmetrical(pRoot, pRoot)
def selfIsSymmetrical(self, pRoot1, pRoot2):
if pRoot1 == None and pRoot2 == None:
return True
if pRoot1 == None or pRoot2 == None:
return False
if pRoot1.val != pRoot2.val:
return False
return self.selfIsSymmetrical(pRoot1.left, pRoot2.right) and self.selfIsSymmetrical(pRoot1.right, pRoot2.left)55.按之字行顺序打印二叉树
class Solution:
def Print(self, pRoot):
# write code here
if not pRoot:
return []
result, nodes = [], [pRoot]
right = True
while nodes:
curStack, nextStack = [], []
if right:
for node in nodes:
curStack.append(node.val)
if node.left:
nextStack.append(node.left)
if node.right:
nextStack.append(node.right)
else:
for node in nodes:
curStack.append(node.val)
if node.right:
nextStack.append(node.right)
if node.left:
nextStack.append(node.left)
nextStack.reverse()
right = not right
result.append(curStack)
nodes = nextStack
return result56. 把二叉树打印成多行
class Solution:
# 返回二维列表[[1,2],[4,5]]
def Print(self, pRoot):
# write code here
if pRoot == None:
return []
nodes = [pRoot]
res = []
while nodes:
curStack, nextStack = [], []
for node in nodes:
curStack.append(node.val)
if node.left:
nextStack.append(node.left)
if node.right:
nextStack.append(node.right)
res.append(curStack)
nodes = nextStack
return res
57. 序列化二叉树
class Solution:
def Serialize(self, root):
serializeStr = ''
if root == None:
return '#'
stack = []
while root or stack:
while root:
serializeStr += str(root.val) + ','
stack.append(root)
root = root.left
serializeStr += '#,'
root = stack.pop()
root = root.right
serializeStr = serializeStr[:-1]
return serializeStr
# write code here
def Deserialize(self, s):
# write code here
serialize = s.split(',')
Tree,sp = self.deserialize(serialize,0)
return Tree
def deserialize(self,s,sp):
if sp >= len(s) or s[sp] == '#':
return None,sp + 1
node = TreeNode(int(s[sp]))
sp += 1
node.left,sp = self.deserialize(s,sp)
node.right,sp = self.deserialize(s,sp)
return node, sp58. 二叉搜索数的第k个节点
class Solution:
# 返回对应节点TreeNode
def KthNode(self, pRoot, k):
# write code here
if k<=0 or not pRoot:
return None
treeStack = []
nodesQue = []
pNode = pRoot
while pNode or len(treeStack):
while pNode:
treeStack.append(pNode)
pNode = pNode.left
if len(treeStack):
pNode = treeStack.pop()
nodesQue.append(pNode)
pNode = pNode.right
if k > len(nodesQue):
return None
return nodesQue[k-1]
59. 数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
class Solution:
def __init__(self):
self.arr=[]
def Insert(self, num):
self.arr.append(num)
self.arr.sort()
def GetMedian(self,fuck):
length=len(self.arr)
if length%2==1:
return self.arr[length//2]
return(self.arr[length//2]+self.arr[length//2-1])/2.060. 滑动窗口的最大值
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{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]}。
61. 机器人的运动范围
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
class Solution:
def movingCount(self, threshold, rows, cols):
# write code here
memories = set()
def dfs(i,j):
def judge(i,j):
return sum(map(int, list(str(i)))) + sum(map(int, list(str(j)))) <= threshold
if not judge(i,j) or (i,j) in memories:
return
memories.add((i,j))
if i != rows - 1:
dfs(i + 1, j)
if j != cols - 1:
dfs(i, j + 1)
dfs(0,0)
return len(memories)
205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
