1.二叉树的镜像（Symmetric Tree）
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
if root == None:
return
self.Mirror(root.left)
self.Mirror(root.right)
root.left,root.right = root.right,root.left
2.链表中环的入口结点
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
if head==None or head.next==None:
return False
slow=fast=head
while fast and fast.next:
slow=slow.next
fast=fast.next.next
if slow == fast:
return True
return False3.删除链表中重复的结点
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.next
4.从头到尾打印链表
class Solution:
# 返回从尾部到头部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
# write code here
ret=[]
head=listNode
while head:
ret.append(head.val)
head=head.next
return ret5.斐波那契数列
class Solution:
def Fibonacci(self, n):
if n==0:
return 0
if n==1 or n==2:
return 1
arr=[1,1]
for i in range(n-2):
arr.append(arr[-1]+arr[-2])
return arr[-1]6.跳台阶
class Solution:
def jumpFloor(self, number):
# write code here
'''
n = 1 : 1
n = 2 : 1+1 = 2
n = 3 : dp[n-2]+dp[n-1]
'''
if number ==1 or number == 2:
return number
dp=[1, 2]
for i in range(number -2 ):
dp.append(dp[-1]+dp[-2])
return dp[-1]7.变态跳台阶
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思考：在dp[n] = dp[n-1] + dp[n-2] + .. + dp[1] + 1(直接跳n)步骤
即dp[n]=∑n−1i=1dp[i]+1
class Solution:
def jumpFloorII(self, number):
# write code here
if number == 1 or number ==2:
return number
ret= sum_a=3
for i in range(number-2):
ret=sum_a+1
sum_a+=ret
return ret8.矩形覆盖
我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思考： 2*1 1 种； 2*2 2种 2*3 3种 2*4 5种
dp[n]=dp[n−1]+dp[n−2]
（同上）
9.把字符串转换成整数
class Solution:
def StrToInt(self, s):
# write code here
flag = True
pos = 1
ret = None
if s=='':
return 0
for i in s:
if i=='+' or i=='-':
if flag:
pos = -1 if i=='-' else 1
flag = False
else:
return 0
elif i>='0' and i<='9':
flag = False
if ret == None:
ret = int(i)
else:
ret = ret*10+int(i)
else:
return 0
return pos*ret if ret else 0
10.平衡二叉树的判断
class Solution(object):
def Treeheight(self, pRoot):
if pRoot == 0:
return 0
if pRoot.left==None and pRoot.right==None:
return 1
lh=self.Treeheight(pRoot.left)
rh=self.Treeheight(pRoot.right)
return max(lh, rh)+1
def is_balance_solution(self, pRoot):
if pRoot is None:
return True
return abs(self.Treeheight(pRoot.left) - self.Treeheight(pRoot.right))<=111.和为S的正数序列
class Solution:
def FindContinuousSequence(self, tsum):
# write code here
k = 2
ret = []
for k in range(2,tsum):
if k%2==1 and tsum%k==0:
tmp = []
mid = tsum/k
if mid-k/2>0:
for i in range(mid-k/2,mid+k/2+1):
tmp.append(i)
ret.append(tmp[:])
elif k%2==0 and (tsum%k)*2==k:
mid = tsum/k
tmp = []
if mid-k/2+1>0:
for i in range(mid-k/2+1,mid+k/2+1):
tmp.append(i)
ret.append(tmp[:])
ret.sort()
return ret
12.左旋转字符串
class Solution(object):
def left_roate_string(self, s, n):
if s == '':
return s
n=n%len(s)
return s[n:] + s[0:n]13.数字在排序数组中出现的次数
class Solution:
def GetNumberOfK(self, data, k):
# write code here
start=0
end=len(data)-1
while start <= end:
mid=(start+end)/2
if data[mid]==k:
cnt=0
tmp=mid
while tmp>=0 and data[tmp]==k:
cnt+=1
tmp-=1
tmp=mid+1
while tmp<len(data) and data[tmp]==k:
cnt+=1
tmp+=1
return cnt
elif data[mid]>k:
end=mid-1
else:
start=end
return 0
14.数组中只出现一次的数字
class Solution:
# 返回[a,b] 其中ab是出现一次的两个数字
def FindNumsAppearOnce(self, array):
# write code here
ans,a1,a2,flag= 0,0,0,1
for num in array:
ans = ans ^ num
while(ans):
if ans%2 == 0:
ans = ans >>1
flag = flag <<1
else:
break
for num in array:
if num & flag:
a1 = a1 ^ num
else:
a2 = a2 ^ num
return a1,a2
15.翻转单词顺序
class Solution:
def ReverseSentence(self, s):
# write code here
ret = s.split(" ")
ret.reverse()
return ' '.join(ret)
16.二叉树的深度
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def TreeDepth(self, pRoot):
# write code here
if pRoot == None:
return 0
if pRoot.left==None and pRoot.right==None:
return 1
return max(self.TreeDepth(pRoot.left), self.TreeDepth(pRoot.right)) + 117.和为s的两个数
class Solution:
def FindNumbersWithSum(self, array, tsum):
# write code here
ret=[]
memorys={}
for num in array:
if tsum - num in array:
if ret==[]:
ret=[tsum-num, num]
elif ret and ret[0]*ret[1]>(tsum-num)*num:
ret=[tsum-num, num]
else:
memorys[num]=1
return ret18.顺时针打印矩阵
class Solution:
# matrix类型为二维列表，需要返回列表
def printMatrix(self, matrix):
# write code here
m=len(matrix)
ans=[]
if m==0:
return ans
n=len(matrix[0])
#ans = [[0 for i in range(n)] for j in range(n)]
#print ans
upper_i =0;lower_i=m-1;left_j=0;right_j=n-1
num=1
i=0;j=0
right_pointer=1
down_pointer=0
while(num<=m*n):
ans.append(matrix[i][j])
if right_pointer==1:
if j<right_j:
j=j+1
else:
right_pointer=0
down_pointer=1
upper_i = upper_i+1
i = i+1
elif down_pointer == 1:
if i<lower_i:
i = i+1
else:
right_pointer=-1
down_pointer=0
right_j = right_j -1
j = j-1
elif right_pointer ==-1:
if j > left_j:
j=j-1
else:
right_pointer=0
down_pointer=-1
lower_i =lower_i-1
i = i-1
elif down_pointer == -1:
if i > upper_i:
i=i-1
else:
right_pointer=1
down_pointer=0
left_j = left_j +1
j = j+1
num=num+1
return ans
19.二叉树的下个结点
class Solution:
def GetNext(self, pNode):
# write code here
# left root right
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 p
20.对称的二叉树
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Symmetrical(self,Lnode,Rnode):
if Lnode == None and Rnode == None:
return True
if Lnode and Rnode:
return Lnode.val == Rnode.val and self.Symmetrical(Lnode.left, Rnode.right) and self.Symmetrical(Lnode.right, Rnode.left)
else:
return False
def isSymmetric(self, pRoot):
if pRoot is None:
return True
return self.Symmetrical(pRoot.left, pRoot.right)21.二叉树打印多行
class Solution:
# 返回二维列表[[1,2],[4,5]]
def Print(self, pRoot):
# write code here
if pRoot == None:
return []
stack = [pRoot]
ret = []
while(stack):
tmpstack = []
tmp = []
for node in stack:
tmp.append(node.val)
if node.left:
tmpstack.append(node.left)
if node.right:
tmpstack.append(node.right)
ret.append(tmp[:])
stack = tmpstack[:]
return ret
22.之字形打印二叉树
class Solution:
def Print(self, pRoot):
# write code here
if pRoot == None:
return []
stack = [pRoot]
step = 1
ret = []
while(stack):
tmpstack = []
tmp = []
for node in stack:
tmp+=[node.val]
if node.left:
tmpstack.append(node.left)
if node.right:
tmpstack.append(node.right)
if step%2==0:
tmp.reverse()
ret.append(tmp)
step += 1
stack = tmpstack[:]
return ret
23.序列化和反序列化的二叉树
class Solution:
def Serialize(self, root):
# write code here
def doit(node):
if node:
vals.append(str(node.val))
doit(node.left)
doit(node.right)
else:
vals.append('#')
vals = []
doit(root)
return ' '.join(vals)
def Deserialize(self, s):
# write code here
def doit():
val = next(vals)
if val == '#':
return None
node = TreeNode(int(val))
node.left = doit()
node.right = doit()
return node
vals = iter(s.split())
return doit()
24.数据流中的中位数---------------
25.二叉平衡树中的第k小数
26.重建二叉树
27.滑动窗口最大值
class Solution:
def maxInWindows(self, num, size):
# write code here
if size == 0:
return []
ret = []
stack = []
for pos in range(len(num)):
while (stack and stack[-1][0] < num[pos]):
stack.pop()
stack.append((num[pos], pos))
if pos>=size-1:
while(stack and stack[0][1]<=pos-size):
stack.pop(0)
ret.append(stack[0][0])
return ret
28.两个栈实现队列
class Solution:
def __init__(self):
self.stack1=[]
self.stack2=[]
def push(self, node):
self.stack1.append(node)
def pop(self):
if len(self.stack2):
return self.stack2.pop()
while(self.stack1):
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
29.旋转数组的最小数字
class Solution:
def minNumberInRotateArray(self, rotateArray):
if rorateArray==[]:
return 0
length=len(rotateArray)
left=0
right=length-1
while left<=right:
mid=int((left+right)/2)
if rotateArray[mid]<rotateArray[mid-1]:
return rotateArray[mid]
if rotateArray[mid]>=rotateArray[right]:
left=mid+1
else:
right=mid-1
return rotateArray[mid]30.丑数--------------
只包含因子2、3和5的数称作丑数（Ugly Number），求按从小到大的顺序的第N个丑数。
31.两个链表的第一个公共结点
def find_first_common_node(pHead1, pHead2):
if pHead1==None and pHead2==None:
return None
pa=pHead1
pb=pHead2
while pa!=pb:
pa.pHead2 if pa is None else pa.next
pb=pHead1 if pb is None else pb.next
return pa32.第一个只出现一次的字符
def find_first_repeat_char(s):
queue=[]
memories=dict()
for idx, char in enumerate(s):
queue.append(idx)
memories[char]
memories[char]+=1
while(queue and memories[s[queue[0]]]>1):
queue.pop(0)
return queue(0) if queue else -133.数组逆序对---------
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
34.连续子数组最大和
def find_greatest_sum_of _array(alist):
if len(alist)<=1:
return alist[0]
local_s=global_s=alist[0]
for i in range(1, len(alist)):
local_s=max(local_s, local_s+alist[i])
global_s=max(global_s, local_s)
return globa35.最小的k个数-------
36.数组中出现超过一半的数字
def more_than_half_num(nums):
#1
nums.sort()
return nums[int(len(nums)/2)]
#2
dict={}
for x in nums:
if x not in dict:
dict[x]=1
else:
dict[x]+=1
for key, value in dict.items():
if value>len(nums)/2:
return key37.从1到n中，1出现的次数------
38.数组中重复的数字
def duplicate(nums):
app=[]
dic={}
for num in nums:
if num not in dic:
dic[num]=True
else:
app.append(num)
return app40.乘积构建组
def multiply(self, A):
# write code here
size = len(A)
B = [1]*size
for i in range(1,size):
B[i] = B[i-1]*A[i-1]
tmp = 1
for i in range(size-2,-1,-1):
tmp = tmp*A[i+1]
B[i] = B[i]*tmp
return B41.二维数组中的查找
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
def find(array, target):
if len(array)==0 or len(array[0])==0:
return None
i=0
j=len(array[0])-1
while (i<len(array) and j>=0):
if array[i][j]==target:
return True
elif array[i][j]>target:
j-=1
else:
i+=1