1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
class Solution:
def Find(self,target, array):
i = 0
j = len(array[0]) - 1
while(i < len(array) and j >= 0):
if target == array[i][j]:
return True
elif target > array[i][j]:
i += 1
else:
j -= 1
return False
if __name__ == '__main__':
solution = Solution()
target = 2
array=[[1,2,3,4],[2,3,4,5],[3,4,5,6],[4,5,6,7]]
result = solution.Find(target, array)
2.请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。注："a"和’a’的区别，前者是字符串，后者是字符。
class Solution:
def replaceSpace(self, string):
string = string.replace(' ', '%20')
return string
if __name__ == '__main__':
solution = Solution()
string = 'We Are Happy'
result = solution.replaceSpace(string)
3.输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def printListFromTailToHead(self, listNode):
l = []
while listNode:
l.append(listNode.val)
listNode = listNode.next
return l.reverse()
if __name__ == '__main__':
A1 = ListNode(1)
A2 = ListNode(2)
A3 = ListNode(3)
A1.next = A2
A2.next = A3
solution=Solution()
result = solution.printListFromTailToHead(A1)
4.输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def reconstructionTree(self, pre, tin):
if len(pre) == 0:
return None
if len(pre) == 1:
return TreeNode(pre[0])
else:
tree = TreeNode(pre[0])
tree.left = self.reconstructionTree(pre[1 : tin.index(pre[0]) + 1], tin[:tin.index(pre[0])])
tree.right = self.reconstructionTree(pre[tin.index(pre[0]) + 1:], tin[tin.index(pre[0])+ 1:])
return tree
if __name__ == '__main__':
solution = Solution()
pre = [1,2,4,7,3,5,6,8]
tin = [4,7,2,1,5,3,8,6]
result = solution.reconstructionTree(pre, tin)
print(result)
5.用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
class Solution():
def __init__(self):
self.stack1 = []
self.stack2 = []
def push(self, x):
self.stack1.append(x)
def pop(self):
if len(self.stack2):
x = self.stack2.pop()
elif len(self.stack1):
for val in self.stack1:
self.stack2.append(val)
x = self.stack2.pop()
return x
if __name__ == '__main__':
solution = Solution()
solution.push(1)
solution.push(2)
solution.push(3)
print(solution.stack1)
x1 =solution.pop()
x2 = solution.pop()
x3 = solution.pop()
solution.push(4)
solution.push(5)
x4 = solution.pop()
6.把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
class Solution:
def minNumberInRotateArray(self, rotateArray):
if not rotateArray:
return 0
front , rear = 0, len(rotateArray) - 1
midIndex = 0
while rotateArray[front] >= rotateArray[rear]:
# if rear - front == 1:
# midIndex = rear
# break
midIndex = (front + rear) // 2
if rotateArray[front] == rotateArray[rear] and rotateArray[front] == rotateArray[midIndex]:
return self.FindMinNumber(rotateArray)
if rotateArray[front] <= rotateArray[midIndex]:
front = midIndex
elif rotateArray[rear] >= rotateArray[midIndex]:
rear = midIndex
return rotateArray[midIndex]
def FindMinNumber(self, rotateArray):
Min = rotateArray[0]
for i in range(rotateArray):
if Min > rotateArray[i]:
Min = rotateArray[i]
return Min
if __name__ == '__main__':
solution = Solution()
rotataArray = [3,4,5,1,2]
result = solution.minNumberInRotateArray(rotataArray)
print(result)
7.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
class Solution:
def Fibonacci(self, n):
if n==0:
return 0
if n==1:
return 1
Fib=[0 for i in range(0,n+1)]
Fib[0], Fib[1] = 0, 1
for i in range(2, n + 1):
Fib[i]=Fib[i-1] + Fib[i-2]
return Fib[n]
def Fibonacci1(self,n):
if n == 0:
return 0
if n == 1:
return 1
else:
return self.Fibonacci1(n-1)+self.Fibonacci1(n-2)
if __name__=='__main__':
solution=Solution()
n=10
ans=solution.Fibonacci1(n)
print(ans)
8.一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
class Solution:
def jumpFloor(self, number):
# write code here
a = 1
b = 1
for i in range(number):
a,b = b,a+b
return a
9.我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
class Solution:
def rectCover(self, number):
if number == 0:
return 0
if number == 1:
return 1
Fib=[0 for i in range(0,number+1)]
Fib[1], Fib[2] = 1, 2
for i in range(3,number+1):
Fib[i] = Fib[i-1]+Fib[i-2]
return Fib[number]
if __name__=='__main__':
solution = Solution()
n = int(input())
ans = solution.rectCover(n)
print(ans)
10.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
class Solution:
def BinaryOf1(self, n):
if n < 0:
n = n & 0xffffffff
count = 1
while n:
n = (n - 1) & n
count += 1
return count
if __name__ == '__main__':
solution = Solution()
result = solution.BinaryOf1(-46)
11.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方
class Solution:
def Power(self, base, exponent):
ans=1
for i in range(0, abs(exponent)):
ans=ans * base
if exponent>0:
return ans
else:
return 1/ans
if __name__=='__main__':
solution=Solution()
base = 5
exponent = -2
result = solution.Power(base,exponent)
print(result)
12.输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
class Solution:
def OrderArray(self, array):
array1 = []
array2 = []
for i in range(len(array)):
if array[i] % 2 == 1:
array1.append(array[i])
else:
array2.append(array[i])
array1.extend(array2)
return array1
if __name__ == '__main__':
array = [7, 2, 3, 6, 10, 8, 11, 13]
solution = Solution()
result = solution.OrderArray(array)
print(result)
13.输入一个链表，输出该链表中倒数第k个结点。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def FindKthToTail(self, head, k):
if head is None or k <= 0:
return
p = head
i = 1 #开始number
while p.next is not None:
p = p.next
i += 1
if k > i:
return
for j in range(i - k):
head = head.next
return head
if __name__=='__main__':
solution=Solution()
k=1
p1=ListNode(1)
p2=ListNode(2)
p3=ListNode(3)
p4=ListNode(4)
p1.next=p2
p2.next=p3
p3.next=p4
ans=solution.FindKthToTail(p1, k)
print(ans.val)
14.输入一个链表，反转链表后，输出新链表的表头。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
# 返回ListNode
def ReverseList(self, pHead):
if pHead is None or pHead.next is None:
return pHead
pre = None
while pHead:
temp = pHead.next
pHead.next = pre
pre = pHead
pHead = temp
return pre
if __name__=='__main__':
solution=Solution()
p1=ListNode(1)
p2=ListNode(2)
p3=ListNode(3)
p1.next=p2
p2.next=p3
ans = solution.ReverseList(p1)
print(ans.val)
15.输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
# 返回合并后列表
def Merge(self, pHead1, pHead2):
p1, p2 = pHead1, pHead2
if p1 and p2:
if p1.val <p2.val:
head = p1
p1 = p1.next
else:
head = p2
p2 = p2.next
cur = head
elif p1:
return p1
else:
return p2
while p1 and p2:
if p1.val < p2.val:
cur.next = p1
p1 = p1.next
else:
cur.next =p2
p2 = p2.next
cur = cur.next
if p1:
cur.next = p1
else:
cur.next = p2
return head
def Merge_rcv(self, pHead1, pHead2):
if not pHead1:
return pHead2
if not pHead2:
return pHead1
if pHead1.val < pHead2.val:
pre = pHead1
pre.next =self.Merge(pHead1.next, pHead2)
else:
pre = pHead2
pre.next = self.Merge(pHead1, pHead2.next)
return pre
if __name__ == '__main__':
Node1 = ListNode(1)
Node2 = ListNode(2)
Node3 = ListNode(3)
Node4 = ListNode(4)
Node5 = ListNode(5)
Node1.next = Node2
Node3.next = Node4
Node4.next = Node5
solution = Solution()
result = solution.Merge(Node1, Node3)
print(result)
16.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def HasSubtree(self, pRoot1, pRoot2):
if pRoot1 is None or pRoot2 is None:
return False
pRoot_result1, pRoot_result2 = [], []
self.order_traversal(pRoot1, pRoot_result1)
self.order_traversal(pRoot2, pRoot_result2)
str1=''.join(str(i) for i in pRoot_result1)
str2=''.join(str(i) for i in pRoot_result2)
print(str1,str2)
if str2 in str1:
return True
else:
return False
def order_traversal(self, root, result):
if not root:
return
self.order_traversal(root.left,result)
result.append(root.val)
self.order_traversal(root.right,result)
if __name__=='__main__':
solution=Solution()
pRootA1 = TreeNode(1)
pRootA2 = TreeNode(2)
pRootA3 = TreeNode(3)
pRootA4 = TreeNode(4)
pRootA5 = TreeNode(5)
pRootA1.left=pRootA2
pRootA1.right=pRootA3
pRootA2.left=pRootA4
pRootA2.right=pRootA5
pRootB2 = TreeNode(2)
pRootB4 = TreeNode(4)
pRootB5 = TreeNode(5)
pRootB2.left=pRootB4
pRootB2.right = pRootB5
ans=solution.HasSubtree(pRootA1,pRootB2)
print(ans)
17.操作给定的二叉树，将其变换为源二叉树的镜像。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
# 返回镜像树的根节点
def Mirror(self, root):
if root is None:
return
if root.left is None and root.right is None:
return
temp = root.left
root.left = root.right
root.right = temp
if root is not None:
self.Mirror(root.left)
if root is not None:
self.Mirror(root.right)
18.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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.
class Solution:
def printMatrix(self, matrix):
res = []
while matrix:
res.extend(matrix.pop(0))
if matrix and matrix[0]:
for row in matrix:
res.append(row.pop())
if matrix:
res.extend(matrix.pop()[::-1])
if matrix and matrix[0]:
for row in matrix[::-1]:
res.append(row.pop(0))
return res
if __name__=='__main__':
solution=Solution()
matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
matrix = [[1],[2],[3],[4],[5]]
result = solution.printMatrix(matrix)
print(result)
19.定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。
# 设置一个辅助栈来保存最小值，每次在原始栈压入元素的时候同时更新辅助栈
class Solution:
def __init__(self):
self.stack = []
self.min_stack = []
def push(self, node):
# write code here
self.stack.append(node) #如果新压入的值比最小值小，则向辅助栈压入新值，否则压入最小值
if self.min_stack == [] or node < self.min():
self.min_stack.append(node)
else:
temp = self.min()
self.min_stack.append(temp)
def pop(self):
# 只要不为空就删除原始栈和辅助栈的元素
if self.min_stack == [] or self.stack == []:
return None
self.min_stack.pop()
self.stack.pop()
def top(self):#返回栈顶
# write code here
return self.stack[-1]
def min(self):
# 返回当前最小值
return self.min_stack[-1]
if __name__=='__main__':
solution = Solution()
solution.push(1)
solution.push(2)
solution.push(3)
solution.push(4)
solution.pop()
print(solution.top())
print(solution.min())
20.输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,21是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）
class Solution:
def IsPopOrder(self, pushv, popv):
if len(pushv) != len(popv):
return False
temp = []
for i in pushv:
temp.append(i)
while temp and temp[-1] == popv[0]:
temp.pop()
popv.pop(0)
if (len(temp)):
return False
return True
22.从上往下打印出二叉树的每个节点，同层节点从左至右打印。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def PrintFromTopToBottom(self, root):
if root is None:
return []
ans = []
ans.append(root.val)
self.orderTrans(root, ans)
return ans
def orderTrans(self, root, ans):
if root is None:
return
if root.left:
ans.append(root.left.val)
if root.right:
ans.append(root.right.val)
self.orderTrans(root.left, ans)
self.orderTrans(root.right, ans)
if __name__=='__main__':
solution=Solution()
A1 = TreeNode(1)
A2 = TreeNode(2)
A3 = TreeNode(3)
A4 = TreeNode(4)
A5 = TreeNode(5)
A6 = TreeNode(6)
A7 = TreeNode(7)
A8 = TreeNode(8)
A9 = TreeNode(9)
A10 = TreeNode(10)
A1.left=A2
A1.right=A3
A2.left=A4
A2.right=A5
A3.left = A6
A3.right = A7
A4.left = A8
A4.right = A9
A8.left = A10
ans=solution.PrintFromTopToBottom(A1)
print(ans)
23.输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
class Solution:
def VerifySquenceOfBST(self, sequence):
if not sequence:
return False
i = 0
while sequence[i] < sequence[-1]:
i = i + 1
k = i
for j in range(i ,len(sequence) - 1):
if sequence[j] < sequence[-1]:
return False
leftsequence = sequence[:k]
rightsequence = sequence[k:-1] #不保留-1结点，-1结点为根节点
leftFlag = True
rightFlag = True
if leftsequence:
self.VerifySquenceOfBST(leftsequence)
if rightsequence:
self.VerifySquenceOfBST(rightsequence)
return leftFlag and rightFlag
24.输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def FindPath(self, root, expectNumber):
if (root is None):
return []
if (root and not root.left and not root.right and root.val == expectNumber):
return [[root.val]]
pathList = []
left = self.FindPath(root.left, expectNumber - root.val)
right = self.FindPath(root.right, expectNumber - root.val)
for i in (left + right):
pathList.append([root.val] + i)
return pathList
25.输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
class RandomListNode:
def __init__(self, x):
self.label = x
self.next = None
self.random = None
class Solution:
def Clone(self ,pHead):
if pHead is None:
return
newHead = RandomListNode(pHead.label)
newHead.next = pHead.next
newHead.random = pHead.random
newHead.next = self.Clone(pHead.next)
return newHead
26.输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def Convert(self, pRootOfTree):
# write code here
if pRootOfTree is None:
return pRootOfTree
if pRootOfTree.left is None and pRootOfTree.right is None:
return pRootOfTree
self.Convert(pRootOfTree.left)
left = pRootOfTree.left
if left:
while left.right:
left = left.right
pRootOfTree.left, left.right = left, pRootOfTree
self.Convert(pRootOfTree.right)
right=pRootOfTree.right
if right:
while right.left:
right=right.left
pRootOfTree.right,right.left=right,pRootOfTree
while pRootOfTree.left:
pRootOfTree=pRootOfTree.left
return pRootOfTree
27.输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba
class Solution:
def Permutation(self, ss):
# write code here
if not ss:
return []
if len(ss)==1:
return [ss]
else:
result=[]
a=ss[-1]
for ii in self.Permutation(ss[:-1]):
for j in range(len(ii)+1):
result.append(ii[:j]+a+ii[j:])
result=list(set(result))
result.sort()
return result
if __name__=='__main__':
# str0='abbcDeefg'
str1='abc'
solution=Solution()
ans=solution.Permutation(str1)
print(ans)
28.数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
class Solution:
def MoreThanHalfNum_Solution(self, numbers):
# write code here
numbers.sort()
theone = numbers[len(numbers)/2]
if numbers.count(theone) > len(numbers)/2:
return theone
return 0
29输入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 tinput is None:
return
n = len(tinput)
if n < k:
return []
tinput = sorted(tinput)
return tinput[:k]
30HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)
class Solution:
def FindGreatestSumOfSubArray(self, array):
# write code here
lst = []
if not array:
return 0
for i in range(len(array)):
max_ = array[i]
lst.append(max_)
for j in range(i+1,len(array)):
max_ += array[j]
lst.append(max_)
lst.sort()
return lst[-1]
31.求出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):
if n <= 0:
return 0
'''若要计算百位上1出现的次数，
它受到了3方面的影响：百位上的数字、百位以下低位上的数字、百位以上高位上的数字。
当百位上数字是0时，受高位数字影响；
当百位上数字是1时，受高位和低位数字影响；
当百位上的数字是2-9时，受高位数字影响。'''
i = 1
res = 0
while n // i:
cur = (n // i) % 10
low = n - i * (n // i)
high = (n // i) // 10
if cur == 0:
res += high * i
elif cur == 1:
res += high * i + low + 1
else:
res += (high + 1) * i
i *= 10
return res
def NumberOf1Between1AndN_Solution2(self, n):
result = 0
for s in range(1,n+1):
list = []
while s>0:
ge = s%10# #每次取得个位数
list.append(ge)
s=s-ge #每次减掉上次的个位数
s=s/10 #将数字除以10
for i in list:
if i == 1.0:
result+=1
return result
if __name__ == '__main__':
solution = Solution()
a = solution.NumberOf1Between1AndN_Solution(219)
print(a)
32.输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为32132
class Solution:
def PrintMinNumber(self, numbers):
if not numbers:
return
for i in range(len(numbers)):
for j in range(i, len(numbers)):
if int(str(numbers[i]) + str(numbers[j])) > int(str(numbers[j]) + str(numbers[i])):
numbers[i], numbers[j] = numbers[j], numbers[i]
ans = ''
num = map(str, numbers)
ans = ans.join(num)
# for i in range(len(numbers)):
## ans = ans+(str(numbers[i]))
#
# print(ans)
return ans
if __name__=='__main__':
numbers=[3,32,321,55,64,11]
solution=Solution()
ans=solution.PrintMinNumber(numbers)
print(ans)
33.把只包含质因子2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14不是，因为它包含质因子7。 习惯上我们把1当做是第一个丑数。求按从小到大的顺序的第N个丑数
class Solution:
def GetUglyNumber_Solution(self, index):
if index <= 0:
return 0
uglyList = [1]
two = 0
three = 0
five = 0
for i in range(index - 1):
newUgly = min(uglyList[two] * 2, uglyList[three] * 3, uglyList[five] * 5)
uglyList.append(newUgly)
#大于当前位置的值，需要更新
if newUgly % 2 == 0:
two += 1
if newUgly % 3 == 0:
three += 1
if newUgly % 5 == 0:
five += 1
return uglyList[-1]
if __name__=='__main__':
solution = Solution()
index = 9
ans = solution.GetUglyNumber_Solution(index)
print(ans)
34.在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）
class Solution:
def FirstNotRepeatingChar(self, s):
# write code here
if not s:
return -1
for i,ch in enumerate(s):
if s.count(ch)==1:
return i
35.在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
class Solution:
def InversePairs(self, data):
count = 0
copy = []
for i in data:
copy.append(i)
copy.sort()
for i in range(len(copy)):
count += data.index(copy[i])
# print(count)
data.remove(copy[i])
return count % 1000000007
a=[1,2,3,4,5,6,7,0]
Solution().InversePairs(a)
36.输入两个链表，找出它们的第一个公共结点。
class ListNode:
def __init__(self, x):
self.val =x
self.next = None
class Solution:
def FindFirstCommonNode(self, pHead1, pHead2):
l1= []
node1 = pHead1
node2 = pHead2
while node1:
l1.append(node1.val)
node1 = node1.next
while node2:
if node2.val in l1:
return node2
else:
node2 = node2.next
if __name__=='__main__':
A1 = ListNode(1)
A2 = ListNode(2)
A3 = ListNode(3)
A1.next = A2
A2.next = A3
B4 = ListNode(4)
B5 = ListNode(5)
B4.next=B5
C6 = ListNode(6)
C7 = ListNode(7)
A3.next = C6
B5.next = C6
C6.next = C7
solution=Solution()
ans=solution.FindFirstCommonNode(A1,B4)
print(ans.val)
37.统计一个数字在排序数组中出现的次数
class Solution:
def GetNumberOfK(self, data, k):
# write code here
ans=0
for i in range(0,len(data)):
if data[i]==k:
ans=ans+1
if data[i]>k:
break
return ans
if __name__=='__main__':
data = [1,2,3,3,3,4,4,5]
k = 3
solution = Solution()
ans = solution.GetNumberOfK(data,k)
print(ans)
38.输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def TreeDepth(self, pRoot):
if pRoot is None:
return 0
left = self.TreeDepth(pRoot.left)
right = self.TreeDepth(pRoot.right)
return (max(left, right) + 1)
if __name__=='__main__':
A1 = TreeNode(1)
A2 = TreeNode(2)
A3 = TreeNode(3)
A4 = TreeNode(4)
A5 = TreeNode(5)
A6 = TreeNode(6)
A1.left=A2
A1.right=A3
A2.left=A4
A2.right=A5
A4.left=A6
solution=Solution()
ans=solution.TreeDepth(A1)
print('ans=',ans)
39.输入一棵二叉树，判断该二叉树是否是平衡二叉树。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def IsBalanced_Solution(self, pRoot):
self.flag = True
self.TreeDepth(pRoot)
return self.flag
def TreeDepth(self, pRoot):
if not pRoot or self.flag==False:
return 0
left = self.TreeDepth(pRoot.left)
right = self.TreeDepth(pRoot.right)
if abs(left-right)>1:
self.flag = False
return left + 1 if left > right else right + 1
if __name__=='__main__':
A1 = TreeNode(1)
A2 = TreeNode(2)
A3 = TreeNode(3)
A4 = TreeNode(4)
A5 = TreeNode(5)
A6 = TreeNode(6)
A1.left=A2
A1.right=A3
A2.left=A4
A2.right=A5
#A4.left=A6
solution=Solution()
ans=solution.IsBalanced_Solution(A1)
print(ans)
40.一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。
class Solution:
# 返回[a,b] 其中ab是出现一次的两个数字
def FindNumsAppearOnce(self, array):
# write code here
tmp = set()
for a in array:
if a in tmp:
tmp.remove(a)
else:
tmp.add(a)
return list(tmp)
41.小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
class Solution:
def FindContinuousSequence(self, tsum):
# write code here
res=[]
for i in range(1,tsum/2+1):
for j in range(i,tsum/2+2):
tmp=(j+i)*(j-i+1)/2
if tmp>tsum:
break
elif tmp==tsum:
res.append(range(i,j+1))
return res
42.输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的
class Solution:
def FindNumbersWithSum(self, array, tsum):
# write code here
ls = []
if not isinstance(array, list):
return ls
for i, v in enumerate(array):
for v1 in array[i:]:
if (v + v1) == tsum:
ls.append([v, v1])
if ls:
return ls[0]
else:
return ls
43.汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
class Solution:
def LeftRotateString(self, s, n):
# write code here
m = len(s)
if m == 0:
return s
b = n % m
return s[b:]+s[:b]
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])
if __name__ == '__main__':
ss = 'student a am i'
solution = Solution()
ans = solution.ReverseSentence(ss)
print(ans)
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):
if numbers is None or len(numbers) <= 0:
return False
transDict = {"J" : 11, "Q" : 12, "K" : 13, "A" : 1}
for i in range(len(numbers)):
if numbers[i] in transDict.keys():
numbers[i] = transDict[numbers[i]]
numbers.sort()
zeroNum = 0
gapNum = 0
i = 0
for i in range(len(numbers)):
if numbers[i] == 0:
zeroNum += 1
small = zeroNum
big = small + 1
while big < len(numbers):
if numbers[small] == numbers[big]:
return False
gapNum += numbers[big] - numbers[small] - 1
small - big
big += 1
46.每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)
# 思路
# 约瑟夫环问题
# -*- coding:utf-8 -*-
class Solution:
def LastRemaining_Solution(self, n, m):
# write code here
if n<1 or m<1:
return -1
last = 0
for i in range(1, n + 1):
last = (last + m) % i
return last
if __name__=='__main__':
n, m = 8, 4
solution = Solution()
ans = solution.LastRemaining_Solution(n, m)
print(ans)
47.求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
class Solution:
def Sum_Solution(self, n):
return n and self.Sum_Solution(n-1) + n
if __name__ == '__main__':
solution = Solution()
ans = solution.Sum_Solution(10)
print(ans)
48.写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
class Solution:
def Add(self, num1, num2):
# write code here
l = []
l.append(num1)
l.append(num2)
return sum(l)
49.将一个字符串转换成一个整数(实现Integer.valueOf(string)的功能，但是string不符合数字要求时返回0)，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0。
class Solution:
def StrToInt(self, s):
if s==None or len(s)==0:
return 0
tem = 0
for i in range(len(s)):
if s[i]>='0' and s[i]<='9':
tem =tem*10+int(s[i])
else:
if i!=0:
return 0
if s[0]=='-':
return -tem
else:
return tem
50.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字
class Solution:
# 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
# 函数返回True/False
def duplicate(self, numbers, duplication):
# write code here
for i in xrange(len(numbers)):
while numbers[i] != i:
print i, numbers[i]
if numbers[i] == numbers[numbers[i]]:
duplication[0] = numbers[i]
return True
else:
t = numbers[i]
numbers[i], numbers[t] = numbers[t], numbers[i]
return False
51.给定一个数组A[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]。不能使用除法。
class Solution:
def multiply(self, A):
# write code here
if not A:
return []
# 计算前面一部分
num = len(A)
B = [None] * num
B[0] = 1
for i in range(1, num):
B[i] = B[i-1] * A[i-1]
# 计算后面一部分
# 自下而上
# 保留上次的计算结果乘本轮新的数,因为只是后半部分进行累加，所以设置一个tmp,能够保留上次结果
tmp = 1
for i in range(num-2, -1, -1):
tmp *= A[i+1]
B[i] *= tmp
return B
52.请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配。
class Solution:
# s, pattern都是字符串
def match(self, s, pattern):
# write code here
if (len(s) == 0 and len(pattern) == 0):
return True
if (len(s) > 0 and len(pattern) == 0):
return False
if (len(pattern) > 1 and pattern[1] == '*'):
if (len(s) > 0 and (s[0] == pattern[0] or pattern[0] == '.')):
return (self.match(s, pattern[2:]) or self.match(s[1:], pattern[2:]) or self.match(s[1:], pattern))
else:
return self.match(s, pattern[2:])
if (len(s) > 0 and (pattern[0] == '.' or pattern[0] == s[0])):
return self.match(s[1:], pattern[1:])
return False
53.请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。
class Solution:
# s字符串
def isNumeric(self, s):
# write code here
import re
return re.match(r"^[\+\-]?[0-9]*(\.[0-9]*)?([eE][\+\-]?[0-9]+)?$",s)
54.请实现一个函数用来找出字符流中第一个只出现一次的字符。例如，当从字符流中只读出前两个字符"go"时，第一个只出现一次的字符是"g"。当从该字符流中读出前六个字符“google"时，第一个只出现一次的字符是"l"。
class Solution:
# 返回对应char
def __init__(self):
self.s = ''
self.dict = {}
def FirstAppearingOnce(self):
# write code here
for i in self.s:
if self.dict[i] == 1:
return i
return '#'
def Insert(self, char):
# write code here
self.s += char
if char in self.dict:
self.dict[char] += 1
else:
self.dict[char] = 1
55.给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。
class Solution:
def EntryNodeOfLoop(self, pHead):
# write code here
#遍历链表，环的存在，遍历遇见的第一个重复的即为入口节点
tempList = []
p = pHead
while p:
if p in tempList:
return p
else:
tempList.append(p)
p = p.next
56.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。
class Solution:
def deleteDuplication(self, pHead):
while pHead and pHead.next and pHead.val==pHead.next.val:
p = pHead
while p and p.val==pHead.val:
p = p.next
pHead = p#新的头节点
if pHead is None or pHead.next is None:
return pHead
p = pHead.next
pre = pHead
while p and p.next:
if p.val==p.next.val:
q = p
while q and q.val==p.val:
q = q.next
pre.next = q
p = q
else:
pre = p
p = p.next
return pHead
57.给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
# -*- coding:utf-8 -*-
# class TreeLinkNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
# self.next = None
class Solution:
def GetNext(self, pNode):
# write code here
if not pNode:
return pNode
if pNode.right:
left1=pNode.right
while left1.left:
left1=left1.left
return left1
p=pNode
while pNode.next:
tmp=pNode.next
if tmp.left==pNode:
return tmp
pNode=tmp
58.请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def isSymmetrical(self, pRoot):
return self.selfIsSymmetrical(pRoot, pRoot)
def selfIsSymmetrical(self, pRoot1, pRoot2):
if not pRoot1 and not pRoot2 :
return True
elif pRoot1 == None or pRoot2 == None:
return False
elif pRoot1.val != pRoot2.val:
return False
return self.selfIsSymmetrical(pRoot1.left, pRoot2.right) and self.selfIsSymmetrical(pRoot1.right, pRoot2.left)
59.请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Print(self, pRoot):
if not pRoot :return []
layers = [[pRoot,]]
while layers[-1] != []:
layer = []
for root in layers[-1]:
if root.left != None:
layer.append(root.left)
if root.right != None:
layer.append(root.right)
layers.append(layer)
ret = []
for i,layer in enumerate(layers[:-1]):
layer_values = [root.val for root in layer]
if i%2 == 1 :
ret.append(layer_values[::-1])
else:
ret.append(layer_values)
return ret
60.从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
# -*- 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 []
nodes, res = [pRoot], []
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)
nodes = nextStack
res.append(curStack)
return res
61.请实现两个函数，分别用来序列化和反序列化二叉树
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def Serialize(self, root):
# write code here
if root == None:
return '#'
return str(root.val) +',' + self.Serialize(root.left) + ','+self.Serialize(root.right)
def Deserialize(self, s):
# write code here
root,index = self.Des(s.split(','),0)
return root
def Des(self,s,index):
if index == len(s):
return root,index
if s[index] == '#':
return None,index+1
root = TreeNode( int(s[index]) )
index += 1
root.left,index = self.Des(s,index)
root.right,index = self.Des(s,index)
return root,index
62.给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
# -*- coding:utf-8 -*-
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 返回对应节点TreeNode
def __init__(self):
self.treeNode= []
def KthNode(self, pRoot, k):
# write code here
if k <= 0 or not pRoot:
return
self.inOrder(pRoot)
if len(self.treeNode) < k:
return None
return self.treeNode[k - 1]
def inOrder(self, pRoot):
if not pRoot:
return None
if pRoot.left:
self.inOrder(pRoot.left)
self.treeNode.append(pRoot)
if pRoot.right:
self.inOrder(pRoot.right)
63.如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数
class Solution:
def __init__(self):
self.data=[]
def Insert(self, num):
# write code here
self.data.append(num)
self.data.sort()
def GetMedian(self,data):
# write code here
length=len(self.data)
if length%2==0:
return (self.data[length//2]+self.data[length//2-1])/2.0
else:
return self.data[int(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]}。
# -*- coding:utf-8 -*-
class Solution:
def maxInWindows(self, num, size):
# write code here
if size <= 0:
return []
res = []
for i in range(0, len(num)-size+1):
res.append(max(num[i:i+size]))
return res
65.请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
# -*- coding:utf-8 -*-
class Solution:
def hasPath(self, matrix, rows, cols, path):
if matrix == None or rows < 1 or cols < 1 or path == None:
return False
visited = [0] * (rows * cols)
pathLength = 0
for row in range(rows):
for col in range(cols):
if self.hasPathCore(matrix, rows, cols, row, col, path, pathLength, visited):
return True
return False
def hasPathCore(self, matrix, rows, cols, row, col, path, pathLength, visited):
if len(path) == pathLength:
return True
hasPath = False
if row >= 0 and row < rows and col >= 0 and col < cols and matrix[row * cols + col] == path[pathLength] and not \
visited[row * cols + col]:
pathLength += 1
visited[row * cols + col] = True
hasPath = self.hasPathCore(matrix, rows, cols, row, col - 1, path, pathLength, visited) or \
self.hasPathCore(matrix, rows, cols, row - 1, col, path, pathLength, visited) or \
self.hasPathCore(matrix, rows, cols, row, col + 1, path, pathLength, visited) or \
self.hasPathCore(matrix, rows, cols, row + 1, col, path, pathLength, visited)
if not hasPath:
pathLength -= 1
visited[row * cols + col] = False
return hasPath
66.地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
# -*- coding:utf-8 -*-
class Solution:
def __init__(self):
self.count = 0
def movingCount(self, threshold, rows, cols):
# write code here
arr = [[1 for i in range(cols)] for j in range(rows)]
self.findway(arr, 0, 0, threshold)
return self.count
def findway(self, arr, i, j, k):
if i < 0 or j < 0 or i >= len(arr) or j >= len(arr[0]):
return
tmpi = list(map(int, list(str(i))))
tmpj = list(map(int, list(str(j))))
if sum(tmpi) + sum(tmpj) > k or arr[i][j] != 1:
return
arr[i][j] = 0
self.count += 1
self.findway(arr, i + 1, j, k)
self.findway(arr, i - 1, j, k)
self.findway(arr, i, j + 1, k)
self.findway(arr, i, j - 1, k)
180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
