面试题四：二维数组的查找
# -*- coding:utf-8 -*-
# array=[[1,2,3],[4,5,6],[7,8,9],[9,10,12]]
# rownum=len(array)
# colnum=len(array[0])
# print(rownum)
# print(colnum)
#思路：这是一个查找过程：首先选取数组中右上角的数字，如果该数字大于要查找的数字，则剔除该数字所在的列；
# 如果该数字小于要查找的数字，则剔除该数字所在的行。
class Solution:
def Find(self,array,target):
#判断数组是否为空
if array==[]:
return False
rownum=len(array)#计算行数
colnum=len(array[0])#计算列数
i=0
j=colnum-1
while i<rownum and j>=0:#注意这儿用的是逻辑运算and而不是位运算&
if array[i][j] > target:
j-=1#剔除列，也就是列数减一
elif array[i][j] <target:
i+=1 #剔除行，也就是行数加一
else:
return True
return False#如果找不到，就是False
def SearchTargetNum(self,matrix,target):#若存在target，计算target的个数
rows=len(matrix)
cols=len(matrix[0])
row=0
col=cols-1
count=0
while row<rows and col>=0:
if matrix[row][col] >target:
col-=1
elif matrix[row][col] <target:
row+=1
else:
count+=1
col-=1
return count
array=[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
array2=[]
findtarget=Solution()#创建一个实例
print(findtarget.Find(array,5))
print(findtarget.SearchTargetNum(array,9))
print(findtarget.Find(array2,9))面试题五：替换空格
# -*- coding:utf-8 -*-
'''
请实现一个函数，将一个字符串中的空格替换成“%20”。
例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
'''
# S="We are happy."
# L=list(S)
# print(L)
class Solution:#从字符串到列表再到字符串的过程
def replaceSpace(self,s):
stringlist=list(s)#把源字符串打散成一个列表
stringReplace=[]#设置一个空列表，用append方法原地添加
for item in stringlist:#列表解析
if item ==' ':#注意引号里要空一格
stringReplace.append("%20")
else:
stringReplace.append(item)
return "".join(stringReplace)#把列表合成一个字符串
s="We arehappy."
replace=Solution()
print(replace.replaceSpace(s))面试题六：从尾到头打印链表
# -*- coding:utf-8 -*-
'''
输入一个链表，从尾到头打印链表每个节点的值。
'''
#思路：定义链表节点，
class ListNode:
def __init__(self,x=None):#值初始化
self.val=x
self.next=None
class Solution:
def PrintListFromTailToHead(self,ListNode):
if ListNode==None:
return []#等价于return None
l=[]
head=ListNode
while head:
l.insert(0,head.val)#始终列表开头插入对象，这样先插入的对象就在后面，后插入的对象就在前面。
head=head.next
return l
node1=ListNode(11)
node2=ListNode(20)
node3=ListNode(34)
node1.next=node2
node2.next=node3
SingleNode=ListNode()
s=Solution()
print(s.PrintListFromTailToHead(node1))
print(s.PrintListFromTailToHead(SingleNode))
# -*- coding:utf-8 -*-
#前序遍历：根--左--右 第一个数字就是根节点的值
#中序遍历：左--根--右 在根节点的左边就是左子树的值，在右边就是右子树的值。
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
# 返回构造的TreeNode根节点,pre指的是前序遍历，tin是中序遍历
def reConstructBinaryTree(self, pre, tin):
#不写这一行，会报错list index out of range,可能出现了空列表,所以判断如果是空列表，返回None
if not pre and not tin:
return None
#要考虑到只有一个元素的情况。
if len(pre)==1:
return TreeNode(pre[0])
else:
#根节点就是前序遍历的第一个值,定义一下根节点的值
root=TreeNode(pre[0])
#找一下根节点在中序遍历里的索引，
i=tin.index(pre[0])
#递归，左子树对应的前序和中序的序列
root.left=self.reConstructBinaryTree(pre[1:i+1],tin[:i])
#右子树对应的前序和中序的序列
root.right=self.reConstructBinaryTree(pre[i+1:],tin[i+1:])
return root
pre = [1, 2, 4,7,3,5,6,8]
tin = [4,7,2,1,5,3,8,6]
s = Solution()
newTree = s.reConstructBinaryTree(pre, tin)面试题九：用两个栈实现队列
# -*- coding:utf-8 -*-
#操作先进后出的栈实现一个先进先出的队列
class Solution:
def __init__(self):
self.stack1=[]
self.stack2=[]
def push(self, node):
# 往栈一压入元素
self.stack1.append(node)
def pop(self):
if len(self.stack1)==0 and len(self.stack2)==0:
return
#如果栈二为空，把栈一的元素逐个弹出并压入栈二
elif len(self.stack2)==0:
while len(self.stack1)>0:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
P = Solution()
P.push(10)
P.push(11)
P.push(12)
print(P.pop())
面试题十：斐波那契数列
# -*- coding:utf-8 -*-
'''
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
n<=39
'''
class Solution:
def Fibonacci(self, n):
tempArray = [0, 1]#初始的两值，之后一直更新这两值，后面一项等于前两项之和。
if n >= 2:
for i in range(2, n + 1):
tempArray[i % 2] = tempArray[0] + tempArray[1]
return tempArray[n % 2]
s=Solution()
print(s.Fibonacci(2))青蛙跳台阶
# -*- coding:utf-8 -*-
#一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
#从斐波那契数列的第二项开始
#青蛙跳台阶。一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个n级的台阶总共有多少种跳法。
#n=1,一种跳法
#n=2,一次跳一个跳两次，一次跳两个跳一次，两种跳法
#n>2,n个台阶，设有f(n)个跳法
#第一次选择跳一个台阶，剩下的n-1个台阶有f(n-1)种跳法；
#第一次选择跳两个台阶，剩下的n-2个台阶有f(n-1)种跳法。
#所以当有n个台阶时，有f(n)=f(n-1)+f(n-2)种跳法。
class Solution:
def jumpFloor(self, number):
# write code here
tempArray=[1,2]
if number>=3:
for i in range(3,number+1):
tempArray[(i+1)%2]=tempArray[0]+tempArray[1]
return tempArray[(number+1)%2]
s=Solution()
print(s.jumpFloor(2))青蛙变态跳台阶
# -*- coding:utf-8 -*-
#一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。f(n）=2^(n-1)
#青蛙变态跳台阶。
#n=1,一种跳法
#n=2,一次跳一个跳两次，一次跳两个跳一次，两种跳法
#n>2,n个台阶，设有f(n)个跳法
#第一次选择跳一个台阶，剩下的n-1个台阶有f(n-1)种跳法；
#第一次选择跳两个台阶，剩下的n-2个台阶有f(n-1)种跳法。
#第一次选择跳三个台阶，剩下的n-3个台阶有f(n-3)种跳法。
#……
#第一次选择跳n个台阶，有1种跳法。
#所以当有n个台阶时，有f(n)=f(n-1)+f(n-2)+f(n-3)+……+f(1)种跳法。
#f(n-1)=f(n-2)+f(n-3)+f(1)
#两式相减，f(n)=2f(n-1)=2^2f(n-2)=……=2^(n-1)f(1)
class Solution:
def jumpFloorII(self, number):
# write code here
ans=1
if number>=2:
for i in range(number-1):#for i in range(n)循环n次
ans=ans*2
return ans
s=Solution()
print(s.jumpFloorII(2))矩形覆盖
# -*- coding:utf-8 -*-
#我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
#将2*n的覆盖方法记为f(n)。
#用第一个2*1的矩形去覆盖大矩形的最左边时有两种选择：横着放和竖着放。
#横着放的时候，左下角必须横着放2*1小矩形，右边还剩下2*(n-2)的区域，有f(n-2)种覆盖方法；
#竖着放的时候，右边还剩下2*(n-1)的区域，有f(n-1)种覆盖方法。
#所以f(n)=f(n-1)+f(n-2)
class Solution:
def rectCover(self, number):
# write code here
#考虑矩形不存在的情况
if number==0:
return 0
tempArray=[1,2]
if number>=3:
for i in range(3,number+1):
tempArray[(i+1)%2]=tempArray[0]+tempArray[1]
return tempArray[(number+1)%2]未完待续。。。。
扫一扫
1044
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
