python讲解剑指offer_剑指offer之Python实现（一）

面试题四：二维数组的查找

# -*- 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=0:#注意这儿用的是逻辑运算and而不是位运算&

if array[i][j] > target:

j-=1#剔除列，也就是列数减一

elif array[i][j] =0:

if matrix[row][col] >target:

col-=1

elif matrix[row][col]

面试题五：替换空格

# -*- 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]

未完待续。。。。