1.在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。
def Find(self, target, array):
# write code here
for i in range(len(array)):
if target in array[i]:
return True
return False
2.请实现一个函数,将一个字符串中的每个空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
def replaceSpace(self, s):
# write code here
return s.replace(' ','%20')
3.输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。
def printListFromTailToHead(self, listNode):
# write code here
l = []
while listNode:
l.append(listNode.val)
listNode = listNode.next
l.reverse()
return l
4.输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6},则重建二叉树并返回。
def reConstructBinaryTree(self, pre, tin):
# write code here
if not pre or not tin:
return None
root = TreeNode(pre.pop(0))
index = tin.index(root.val)
root.left = self.reConstructBinaryTree(pre,tin[:index])
root.right = self.reConstructBinaryTree(pre,tin[index+1:])
return root
5.用两个栈来实现一个队列,完成队列的Push和Pop操作。 队列中的元素为int类型。
def __init__(self):
self.stack1 = [] #定义一个模仿入队列
self.stack2 = [] #定义一个出队列
def push(self, node):
# write code here
self.stack1.append(node)
def pop(self):
# return xx
if len(self.stack2) != 0: #判断出队列是否还有值,如果有这弹出反之入队列弹出出队列压入再弹出
return self.stack2.pop()
else:
while len(self.stack1) != 0:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
6.把一个数组最开始的若干个元素搬到数组的末尾,我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转,输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转,该数组的最小值为1。 NOTE:给出的所有元素都大于0,若数组大小为0,请返回0。
def minNumberInRotateArray(self, rotateArray):
# write code here
for i in range(1,len(rotateArray)):
if rotateArray[i] >= rotateArray[i-1]:
continue
else:
return rotateArray[i]
7.大家都知道斐波那契数列,现在要求输入一个整数n,请你输出斐波那契数列的第n项(从0开始,第0项为0)。
n<=39
def Fibonacci(self, n):
# write code here
if n == 0:
return 0
if n == 1:
return 1
l = []
l.append(0)
l.append(1)
for i in range(2,n+1):
l.append(l[i-1] + l[i-2]) #开始用的是l[i] = l[i-1] + l[i-2] 导致列表越界
return l[n]
8.一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法(先后次序不同算不同的结果)。
def jumpFloor(self, number):
# write code here
a = 1
b = 1
for i in range(number):
a,b = b,a+b
return a
9.略
10.输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示。
def NumberOf1(self, n):
# write code here
if n >=0:
return bin(n).count('1')
else:
n = -n #把负数转化为正数
s = bin(n)[2:] #截掉开始的0b,从第二位开始的
s = '0'*(32-len(s))+s # 如果求得长度不足32位前边补零
l = [int(i) for i in s]
for i in range(len(l)): #取反
if l[i] == 1:
l[i] = 0
else:
l[i] = 1
for i in range(len(l)-1,-1,-1): #加一
if l[i] == 0:
l[i] = 1
break
else:
l[i] = 0
return l.count(1)
11.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
def Power(self, base, exponent):
# write code here
return base ** exponent
12.输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。
def reOrderArray(self, array):
# write code here
l1 = []
l2 = []
for i in array:
if i % 2 != 0:
l1.append(i)
else:
l2.append(i)
return l1+l2
13.输入一个链表,输出该链表中倒数第k个结点。
def FindKthToTail(self, head, k):
# write code here
if head == None:
return None
l = []
while head:
l.append(head)
head = head.next
if k>len(l) or k == 0:
return None
return l[-k]
14.输入一个链表,反转链表后,输出新链表的表头。
def ReverseList(self, pHead):
# write code here
if pHead == None or pHead.next == None: # 判断链表为空或者一个节点
return pHead
last = None
while pHead:
temp = pHead.next #获取下一个节点
pHead.next = last # 第一个节点的next指向空,剩下节点指向前一个节点实现反转
last = pHead # last指向反转后的链表的头结点
pHead = temp # phead指向原剩余节点的头结点
return last
15.输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。
def Merge(self, pHead1, pHead2):
# write code here
if pHead1 == None and pHead2 == None:
return None
p = ListNode(90)
pHead = p
while pHead1 and pHead2:
if pHead1.val > pHead2.val:
pHead.next = pHead2
pHead2 = pHead2.next
pHead = pHead.next
else:
pHead.next = pHead1
pHead1 = pHead1.next
pHead = pHead.next
if pHead1:
pHead.next = pHead1
if pHead2:
pHead.next = pHead2
return p.next
16.输入两棵二叉树A,B,判断B是不是A的子结构。(ps:我们约定空树不是任意一个树的子结构)
def HasSubtree(self, pRoot1, pRoot2):
# write code here
if not pRoot1 or not pRoot2:
return False
return self.is_subtree(pRoot1,pRoot2) or self.HasSubtree(pRoot1.left,pRoot2) or self.HasSubtree(pRoot1.right,pRoot2)
def is_subtree(self,A,B):
if not B:
return True
if not A or A.val != B.val:
return False
return self.is_subtree(A.left,B.left) and self.is_subtree(A.right,B.right)
17.操作给定的二叉树,将其变换为源二叉树的镜像。
def Mirror(self, root):
# write code here
if root != None:
root.left,root.right = root.right,root.left
self.Mirror(root.left)
self.Mirror(root.right)
return root
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.
def printMatrix(self, matrix):
# write code here
res = []
m = len(matrix) #行数
n = len(matrix[0]) #列数
if m == 1 and n == 1:
return [matrix[0][0]]
for o in range((min(m,n)+1)//2):
[res.append(matrix[o][i]) for i in range(o,n-o)]
[res.append(matrix[j][n-1-o]) for j in range(o,m-o) if matrix[j][n-1-o] not in res]
[res.append(matrix[m-1-o][k]) for k in range(n-1-o,o-1,-1) if matrix[m-1-o][k] not in res]
[res.append(matrix[l][o]) for l in range(m-1-o,o-1,-1) if matrix[l][o] not in res]
return res
19.定义栈的数据结构,请在该类型中实现一个能够得到栈中所含最小元素的min函数(时间复杂度应为O(1))。
在这里插入代码片
20.输入两个整数序列,第一个序列表示栈的压入顺序,请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序,序列4,5,3,2,1是该压栈序列对应的一个弹出序列,但4,3,5,1,2就不可能是该压栈序列的弹出序列。(注意:这两个序列的长度是相等的)。
def IsPopOrder(self, pushV, popV):
# write code here
for i in pushV:
if i not in popV:
return False
res = []
while len(popV):
v = popV.pop(0)
if v not in res:
while True:
p = pushV.pop(0)
if p == v:
break
res.append(p)
else:
if v == res[-1]:
res.pop()
else:
return False
return True
21.从上往下打印出二叉树的每个节点,同层节点从左至右打印。
def PrintFromTopToBottom(self, root):
# write code here
if root == None:
return []
l = [root]
res = []
while len(l):
L = []
for i in l:
res.append(i.val)
if i.left:
L.append(i.left)
if i.right:
L.append(i.right)
l = L
return res
22.输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
def duplicate(self, numbers, duplication):
# write code here
flag = False
for i in numbers:
if numbers.count(i) > 1:
flag = True
duplication[0] = i
break
return flag
23.给一个链表,若其中包含环,请找出该链表的环的入口结点,否则,输出null。
方法一:
def EntryNodeOfLoop(self, pHead):
# write code here
if not pHead:
return None
l = []
while pHead:
v = pHead.val
if v in l:
return pHead
l.append(v)
pHead = pHead.next
return None
方法二:
def EntryNodeOfLoop(self, pHead):
# write code here
if not pHead or not pHead.next:
return None
fast = pHead
slow = pHead
while True:
fast = fast.next.next
slow = slow.next
if fast.val == slow.val:
break
fast = pHead
while True:
if fast == slow:
return fast
fast = fast.next
slow = slow.next
24.输入两个链表,找出它们的第一个公共结点。
def FindFirstCommonNode(self, pHead1, pHead2):
# write code here
p1 = pHead1
p2 = pHead2
l = []
while p1:
l.append(p1.val)
p1 = p1.next
while p2:
if p2.val in l:
return p2
p2 = p2.next
return None
def FindFirstCommonNode(self, pHead1, pHead2):