當前位置：首頁 > 编程语言 > python >内容正文

python

剑指offer-python解答

發布時間：2024/7/5 python 25 豆豆

生活随笔收集整理的這篇文章主要介紹了剑指offer-python解答小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

版權聲明： https://blog.csdn.net/XiaoYi_Eric/article/details/81452014 </div><link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-f57960eb32.css"><div id="content_views" class="markdown_views prism-atom-one-dark"><svg xmlns="http://www.w3.org/2000/svg" style="display: none;"><path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path></svg><h3><a name="t0"></a><a id="1_0" target="_blank"></a>1.二維數組中的查找</h3>

題目： 在一個二維數組中（每個一維數組的長度相同），每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。

**思路：**遍歷每一行，查找該元素是否在該行之中。

# -*- coding:utf-8 -*- class Solution:# array 二維列表def Find(self, target, array):# write code herefor line in array:if target in line:return Truereturn False

if name==‘main’:
target=2
array=[[1,2,3,4],[2,3,4,5],[3,4,5,6],[4,5,6,7]]
solution=Solution()
ans=solution.Find(target,array)
print(ans)

2.替換空格

題目： 請實現一個函數，將一個字符串中的每個空格替換成“%20”。例如，當字符串為We Are Happy.則經過替換之后的字符串為We%20Are%20Happy。

**思路：**利用字符串中的replace直接替換即可。

# -*- coding:utf-8 -*- class Solution:# s 源字符串def replaceSpace(self, s):# write code heretemp = s.replace(" ", "%20")return temp

if name==‘main’:
s=‘We Are Happy’
solution=Solution()
ans=solution.replaceSpace(s)
print(ans)

3.從尾到頭打印鏈表

**題目：**輸入一個鏈表，按鏈表值從尾到頭的順序返回一個ArrayList。

**思路：**將鏈表中的值記錄到list之中，然后進行翻轉list。

# -*- coding:utf-8 -*- class ListNode:def __init__(self, x):self.val = xself.next = None

class Solution:
# 返回從尾部到頭部的列表值序列，例如[1,2,3]
def printListFromTailToHead(self, listNode):
# write code here
l=[]
while listNode:
l.append(listNode.val)
listNode=listNode.next
return l[::-1]

if name==‘main’:
A1 = ListNode(1)
A2 = ListNode(2)
A3 = ListNode(3)
A4 = ListNode(4)
A5 = ListNode(5)

A1.next=A2 A2.next=A3 A3.next=A4 A4.next=A5solution=Solution() ans=solution.printListFromTailToHead(A1) print(ans)

4.重建二叉樹

**題目：**輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重復的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹并返回。

**題解：**首先前序遍歷的第一個元素為二叉樹的根結點，那么便能夠在中序遍歷之中找到根節點，那么在根結點左側則是左子樹，假設長度為M.在根結點右側，便是右子樹,假設長度為N。然后在前序遍歷根節點后面M長度的便是左子樹的前序遍歷序列，再后面的N個長度便是右子樹的后序遍歷的長度。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
# 返回構造的TreeNode根節點
def reConstructBinaryTree(self, pre, tin):
# write code here
if len(pre)0:
return None
if len(pre)1:
return TreeNode(pre[0])
else:
flag=TreeNode(pre[0])
flag.left=self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
flag.right=self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
return flag

if name==‘main’:
solution=Solution()
pre=list(map(int,input().split(’,’)))
tin=list(map(int,input().split(’,’)))
ans=solution.reConstructBinaryTree(pre,tin)
print(ans.val)

5.用兩個棧實現隊列

**題目：**用兩個棧來實現一個隊列，完成隊列的Push和Pop操作。隊列中的元素為int類型。

**題解：**申請兩個棧Stack1和Stack2，Stack1當作輸入，Stack2當作pop。當Stack2空的時候，將Stack1進行反轉，并且輸入到Stack2。

# -*- coding:utf-8 -*- class Solution:def __init__(self):self.Stack1=[]self.Stack2=[]def push(self, node):# write code hereself.Stack1.append(node)def pop(self):# return xxif self.Stack2==[]:while self.Stack1:self.Stack2.append(self.Stack1.pop())return self.Stack2.pop()return self.Stack2.pop()

if name==‘main’:
solution = Solution()
solution.push(1)
solution.push(2)
solution.push(3)
print(solution.pop())

6.旋轉數組的最小數字

**題目：**把一個數組最開始的若干個元素搬到數組的末尾，我們稱之為數組的旋轉。輸入一個非減排序的數組的一個旋轉，輸出旋轉數組的最小元素。例如數組{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉，該數組的最小值為1。NOTE：給出的所有元素都大于0，若數組大小為0，請返回0。

**題解：**遍歷數組尋找數組最小值。

# -*- coding:utf-8 -*- class Solution:def minNumberInRotateArray(self, rotateArray):# write code hereminnum=999999for i in range(0,len(rotateArray)):if minnum>rotateArray[i]:minnum=rotateArray[i]if minnum:return minnumelse:return 0

if name==‘main’:
solution=Solution()
rotateArray=list(map(int,input().split(’,’)))
ans=solution.minNumberInRotateArray(rotateArray)
print(ans)

7.斐波那契數列

**題目：**大家都知道斐波那契數列，現在要求輸入一個整數n，請你輸出斐波那契數列的第n項。n<=39。

**題解：**遞歸和非遞歸方法。

# -*- coding:utf-8 -*- class Solution:def Fibonacci(self, n):# write code hereif n==0:return 0if n==1:return 1Fib=[0 for i in range(0,n+1)]Fib[0],Fib[1]=0,1for 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 0if n==1 or n==2:return 1else:return self.Fibonacci1(n-1)+self.Fibonacci1(n-2)

if name==‘main’:
solution=Solution()
n=int(input())
ans=solution.Fibonacci1(n)
print(ans)

8.跳臺階

**題目：**一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法（先后次序不同算不同的結果）。

**題解：**ans[n]=ans[n-1]+ans[n-2]

class Solution:def jumpFloor(self, number):# write code hereif number==0:return 0if number==1:return 1if number==2:return 2ans=[0 for i in range(0,number+1)]ans[1],ans[2]=1,2for i in range(3,number+1):ans[i]=ans[i-1]+ans[i-2]return ans[number]

if name == ‘main’:
solution = Solution()
n=int(input())
ans=solution.jumpFloor(n)
print(ans)

9.變態跳臺階

**題目：**一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。

**題解：**ans[n]=ans[n-1]+ans[n-2]+ans[n-3]+…+ans[n-n]，ans[n-1]=ans[n-2]+ans[n-3]+…+ans[n-n]，ans[n]=2*ans[n-1]。

# -*- coding:utf-8 -*- class Solution:def jumpFloorII(self, number):# write code hereif number==1:return 1if number==2:return 2return 2*self.jumpFloorII(number-1)

if name==‘main’:
solution=Solution()
n=int(input())
ans=solution.jumpFloorII(n)
print(ans)

10.矩形覆蓋

**題目：**我們可以用21的小矩形橫著或者豎著去覆蓋更大的矩形。請問用n個21的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？

**題解：**新增加的小矩陣豎著放，則方法與n-1時相同，新增加的小矩陣橫著放，則方法與n-2時相同，于是f(n)=f(n-1)+f(n-2)。

# -*- coding:utf-8 -*- class Solution:def rectCover(self, number):# write code hereif number==0:return 0if number==1:return 1Fib=[0 for i in range(0,number+1)]Fib[1],Fib[2]=1,2for 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)

11.二進制中1的個數

**題目：**輸入一個整數，輸出該數二進制表示中1的個數。其中負數用補碼表示。

**題解：**每次進行左移一位，然后與1進行相與，如果是1則進行加1。

# -*- coding:utf-8 -*- class Solution:def NumberOf1(self, n):# write code herecount = 0for i in range(32):count += (n >> i) & 1return count

if name==‘main’:
solution=Solution()
n=int(input())
ans=solution.NumberOf1(n)
print(ans)

12.數值的整次方

**題目：**給定一個double類型的浮點數base和int類型的整數exponent。求base的exponent次方。

# -*- coding:utf-8 -*- class Solution:def Power(self, base, exponent):# write code hereans=1for i in range(0,abs(exponent)):ans=ans*baseif exponent>0:return anselse:return 1/ans

if name==‘main’:
solution=Solution()
base=float(input())
exponent=int(input())
ans=solution.Power(base,exponent)
print(ans)

13.調整數組順序使奇數位于偶數前面

**題目：**輸入一個整數數組，實現一個函數來調整該數組中數字的順序，使得所有的奇數位于數組的前半部分，所有的偶數位于位于數組的后半部分，并保證奇數和奇數，偶數和偶數之間的相對位置不變。

**題解：**申請奇數數組和偶數數組，分別存放奇數值和偶數值，數組相加便為結果。

# -*- coding:utf-8 -*- class Solution:def reOrderArray(self, array):# write code herearray1=[]#奇數array2=[]#偶數 for i in range(0,len(array)):if array[i]%2!=0:array1.append(array[i])else:array2.append(array[i])ans=array1+array2return ans

if name==‘main’:
solution=Solution()
array=list(map(int,input().split(’,’)))
ans=solution.reOrderArray(array)
print(ans)

14.鏈表中倒數第K個節點

**題目：**輸入一個鏈表，輸出該鏈表中倒數第k個結點。

**題解：**反轉鏈表，尋找第K個節點。

# -*- coding:utf-8 -*- class ListNode:def __init__(self, x):self.val = xself.next = None

class Solution:
def FindKthToTail(self, head, k):
# write code here
#反轉鏈表
if head is None or head.next is None:
return head
pre=None #指向上一個節點
while head:
#先用temp保存當前節點的下一個節點信息
temp=head.next
#保存好next之后，便可以指向上一個節點
head.next=pre
#讓pre,head指向下一個移動的節點
pre=head
head=temp
# 尋找第K個元素的位置
for i in range(1,k):
pre=pre.next
temp=pre
return temp

if name==‘main’:
solution=Solution()
k=3
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)

15.反轉鏈表

**題目：**輸入一個鏈表，反轉鏈表后，輸出新鏈表的表頭。

# -*- coding:utf-8 -*- class ListNode:def __init__(self, x):self.val = xself.next = None

class Solution:
# 返回ListNode
def ReverseList(self, pHead):
# write code here
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)

16.合并兩個排序的列表

**題目：**輸入兩個單調遞增的鏈表，輸出兩個鏈表合成后的鏈表，當然我們需要合成后的鏈表滿足單調不減規則。

**題解：**將兩個鏈表之中的數值轉換到列表之中，并進行排序，將排序后的列表構造成鏈表。

# -*- coding:utf-8 -*- class ListNode:def __init__(self, x):self.val = xself.next = None

class Solution:
# 返回合并后列表
def Merge(self,pHead1,pHead2):
# write code here
if pHead1 is None and pHead2 is None:
return None
num1,num2=[],[]
while pHead1:
num1.append(pHead1.val)
pHead1=pHead1.next
while pHead2:
num2.append(pHead2.val)
pHead2=pHead2.next
ans=num1+num2
ans.sort()
head=ListNode(ans[0])
pre=head
for i in range(1,len(ans)):
node=ListNode(ans[i])
pre.next=node
pre=pre.next
return head

if name==‘main’:
solution=Solution()
pHead1_1 = ListNode(1)
pHead1_2 = ListNode(3)
pHead1_3 = ListNode(5)
pHead1_1.next=pHead1_2
pHead1_2.next=pHead1_3

pHead2_1 = ListNode(2) pHead2_2 = ListNode(4) pHead2_3 = ListNode(6) pHead2_1.next=pHead2_2 pHead2_2.next=pHead2_3 ans=solution.Merge(pHead1_1,pHead2_1) print(ans)

17.樹的子結構

**題目：**輸入兩棵二叉樹A，B，判斷B是不是A的子結構。（ps：我們約定空樹不是任意一個樹的子結構）。

**題解：**將樹轉變為中序序列，然后轉變為str類型，最后判斷是否包含。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
def HasSubtree(self, pRoot1, pRoot2):
# write code here
if pRoot1 is None or pRoot2 is None:
return False
pRoot1_result,pRoot2_result=[],[]
self.order_traversal(pRoot1,pRoot1_result)
self.order_traversal(pRoot2,pRoot2_result)
str1=’’.join(str(i) for i in pRoot1_result)
str2=’’.join(str(i) for i in pRoot2_result)
print(str1,str2)
if str2 in str1:
return True
else:
return False

def order_traversal(self,root,result):if not root:returnself.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)

18.二叉樹的鏡像

題目： 操作給定的二叉樹，將其變換為源二叉樹的鏡像。

輸入描述：

? 源二叉樹
8
/
6 10
/ \ /
5 7 9 11
鏡像二叉樹
8
/
10 6
/ \ /
11 9 7 5

**思路：**遞歸實現反轉每個子節點

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
# 返回鏡像樹的根節點
def Mirror(self, root):
# write code here
# A1_order_result=[]
# self.order_traversal(A1,A1_order_result)
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)def order_traversal(self,root,result):if not root:returnself.order_traversal(root.left,result)result.append(root.val)self.order_traversal(root.right,result)

if name==‘main’:
A1 = TreeNode(8)
A2 = TreeNode(6)
A3 = TreeNode(10)
A4 = TreeNode(5)
A5 = TreeNode(7)
A6 = TreeNode(9)
A7 = TreeNode(11)
A1.left=A2
A1.right=A3
A2.left=A4
A2.right=A5
A3.left=A6
A3.right=A7

temp1=[] solution=Solution() solution.order_traversal(A1,temp1) print(temp1) solution.Mirror(A1) solution.order_traversal(A1,temp1) print(temp1)

19.順時針打印矩陣

題目：

輸入一個矩陣，按照從外向里以順時針的順序依次打印出每一個數字，例如，如果輸入如下矩陣：1 2 3 45 6 7 89 10 11 1213 14 15 16 則依次打印出數字 1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

**思路：**每次打印圈，但要判斷最后一次是打印橫還是豎，另外判斷數據是否已存在。

# -*- coding:utf-8 -*- class Solution:# matrix類型為二維列表，需要返回列表def printMatrix(self, matrix):# write code herem,n=len(matrix),len(matrix[0])res = []if n==1 and m==1:res.append(matrix[0][0])return resfor k in range(0,(min(m,n)+1)//2):[res.append(matrix[k][i]) for i in range(k, n - k)][res.append(matrix[j][n-k-1]) for j in range(k,m-k) if matrix[j][n-k-1] not in res][res.append(matrix[m-k-1][j]) for j in range(n-k-1,k-1,-1) if matrix[m-k-1][j] not in res][res.append(matrix[j][k]) for j in range(m-1-k,k-1,-1) if matrix[j][k] not in res]return res

if name==‘main’:
solution=Solution()
m,n=1,5
matrix=[]
for i in range(0,m):
matrix.append(list(map(int,input().split(’ '))))
print(matrix)
ans=solution.printMatrix(matrix)
print(ans)

20.包含Min函數的棧

**題目：**定義棧的數據結構，請在該類型中實現一個能夠得到棧中所含最小元素的min函數。

# -*- coding:utf-8 -*- class Solution:def __init__(self):self.num=[]def push(self, node):# write code hereself.num.append(node)def pop(self):# write code hereself.num.pop()def top(self):# write code herenumlen = len(self.num)return self.num[numlen-1]def min(self):# write code herereturn min(self.num)

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())

21.棧的壓入彈出序列

**題目：**輸入兩個整數序列，第一個序列表示棧的壓入順序，請判斷第二個序列是否可能為該棧的彈出順序。假設壓入棧的所有數字均不相等。例如序列1,2,3,4,5是某棧的壓入順序，序列4,5,3,2,1是該壓棧序列對應的一個彈出序列，但4,3,5,1,2就不可能是該壓棧序列的彈出序列。（注意：這兩個序列的長度是相等的）。

**題解：**新構建一個中間棧，來模擬棧的輸入和棧的輸出，比對輸入結果和輸出結果是否相等。

# -*- coding:utf-8 -*- class Solution:def IsPopOrder(self, pushV, popV):# write code hereif len(pushV)==1 and len(popV)==1 and pushV[0]!=popV[0]:return False helpV=[]pushV.reverse()popV.reverse()#模擬給定棧的壓入和壓出helpV.append(pushV[len(pushV)-1])pushV.pop()while True:if helpV[len(helpV)-1]!=popV[len(popV)-1]:helpV.append(pushV[len(pushV)-1])pushV.pop()if helpV[len(helpV)-1]==popV[len(popV)-1]:helpV.pop()popV.pop()if pushV==[] and popV==[] and helpV==[]:return Trueif pushV==[] and popV[len(popV)-1]!=helpV[len(helpV)-1]:return False

if name==‘main’:
solution=Solution()
push=list(map(int,input().split(’ ‘)))
pop=list(map(int,input().split(’ ')))
ans=solution.IsPopOrder(push,pop)
print(ans)

22.從上往下打印二叉樹

**題目：**從上往下打印出二叉樹的每個節點，同層節點從左至右打印。

**思路：**遞歸，每次將左子樹結果和右子樹結果存到結果集之中。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
# 返回從上到下每個節點值列表，例：[1,2,3]
def PrintFromTopToBottom(self, root):
# write code here
if root is None:
return []
ans=[]
ans.append(root.val)
self.orderans(root,ans)
return ans

def orderans(self,root,ans):if not root:returnif root.left:ans.append(root.left.val)if root.right:ans.append(root.right.val)self.orderans(root.left, ans)self.orderans(root.right,ans)

if name==‘main’:
solution=Solution()
A1 = TreeNode(1)
A2 = TreeNode(2)
A3 = TreeNode(3)
A4 = TreeNode(4)
A5 = TreeNode(5)

23.二叉樹的后續遍歷序列

**題目：**輸入一個整數數組，判斷該數組是不是某二叉搜索樹的后序遍歷的結果。如果是則輸出Yes,否則輸出No。假設輸入的數組的任意兩個數字都互不相同。

**思路：**二叉搜索樹的特性是所有左子樹值都小于中節點，所有右子樹的值都大于中節點，遞歸遍歷左子樹和右子樹的值。

# -*- coding:utf-8 -*- class Solution:def VerifySquenceOfBST(self, sequence):# write code hereif not sequence:return Falseif len(sequence)==1:return Truei=0while sequence[i]<sequence[-1]:i=i+1k=ifor j in range(i,len(sequence)-1):if sequence[j]<sequence[-1]:return False leftsequence=sequence[:k]rightsequence=sequence[k:len(sequence)-1]leftans=Truerightans=Trueif len(leftsequence)>0:self.VerifySquenceOfBST(leftsequence)if len(rightsequence)>0:self.VerifySquenceOfBST(rightsequence)return leftans and rightans

if name==‘main’:
solution=Solution()
num=list(map(int,input().split(’ ')))
ans=solution.VerifySquenceOfBST(num)
print(ans)

24.二叉樹中和為某一值的路徑

**題目：**輸入一顆二叉樹的根節點和一個整數，打印出二叉樹中結點值的和為輸入整數的所有路徑。路徑定義為從樹的根結點開始往下一直到葉結點所經過的結點形成一條路徑。(注意: 在返回值的list中，數組長度大的數組靠前)。

**思路：**利用遞歸的方法，計算加左子樹和右子樹之后的值，當參數較多是，可以將結果添加到函數變量之中。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
# 返回二維列表，內部每個列表表示找到的路徑
def FindPath(self, root, expectNumber):
# write code here
if not root:
return []
ans=[]
path=[]
self.dfs(root,expectNumber,ans,path)
ans.sort()
return ans

def dfs(self,root,target,ans,path):if not root:returnpath.append(root.val)if root.left is None and root.right is None and target==root.val:ans.append(path[:])if root.left:self.dfs(root.left,target-root.val,ans,path)if root.right:self.dfs(root.right,target-root.val,ans,path)path.pop()

if name==‘main’:
A1=TreeNode(10)
A2=TreeNode(8)
A3=TreeNode(12)
A4=TreeNode(4)
A5=TreeNode(2)
A6=TreeNode(2)

A1.left=A2 A1.right=A3 A2.left=A4 A2.right=A5 A5.left=A6expectNumber=22 solution=Solution() ans=solution.FindPath(A1,expectNumber) print(ans)

25.復雜鏈表的復制

**題目：**輸入一個復雜鏈表（每個節點中有節點值，以及兩個指針，一個指向下一個節點，另一個特殊指針指向任意一個節點），返回結果為復制后復雜鏈表的head。（注意，輸出結果中請不要返回參數中的節點引用，否則判題程序會直接返回空）。

**思路：**將大問題轉變為小問題，每次都進行復制頭部節點，然后進行遞歸，每次同樣處理頭部節點。

# -*- coding:utf-8 -*- class RandomListNode:def __init__(self, x):self.label = xself.next = Noneself.random = None

class Solution:
# 返回 RandomListNode
def Clone(self, pHead):
# write code here
# 復制頭部節點
if pHead is None:
return None

newHead=RandomListNode(pHead.label)newHead.next=pHead.nextnewHead.random=pHead.random# 遞歸其他節點newHead.next=self.Clone(pHead.next)return newHead

if name==‘main’:
A1=RandomListNode(2)
A2=RandomListNode(3)
A3=RandomListNode(4)
A4=RandomListNode(5)
A5=RandomListNode(6)

A1.next=A2 A1.random=A3A2.next=A3 A2.random=A4A3.next=A4 A3.random=A5A4.next=A5 A4.random=A3solution=Solution() ans=solution.Clone(A1)

26.二叉搜索樹與雙向列表

**題目：**輸入一棵二叉搜索樹，將該二叉搜索樹轉換成一個排序的雙向鏈表。要求不能創建任何新的結點，只能調整樹中結點指針的指向。

**思路：**遞歸將根結點和左子樹的最右節點和右子樹的最左節點進行連接起來。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None class Solution:def Convert(self, pRootOfTree):# write code hereif pRootOfTree is None:return pRootOfTreeif pRootOfTree.left is None and pRootOfTree.right is None:return pRootOfTree #處理左子樹self.Convert(pRootOfTree.left)left=pRootOfTree.leftif left:while left.right:left=left.rightpRootOfTree.left,left.right=left,pRootOfTree#處理右子樹self.Convert(pRootOfTree.right)right=pRootOfTree.rightif right:while right.left:right=right.leftpRootOfTree.right,right.left=right,pRootOfTreewhile pRootOfTree.left:pRootOfTree=pRootOfTree.leftreturn pRootOfTree

if name==‘main’:
A1 = TreeNode(7)
A2 = TreeNode(5)
A3 = TreeNode(15)
A4 = TreeNode(2)
A5 = TreeNode(6)
A6 = TreeNode(8)
A7 = TreeNode(19)
A8 = TreeNode(24)

A1.left=A2 A1.right=A3 A2.left=A4 A2.right=A5 A3.left=A6 A3.right=A7 A7.right=A8solution=Solution() solution.Convert(A1)

27.字符串的排列

**題目：**輸入一個字符串,按字典序打印出該字符串中字符的所有排列。例如輸入字符串abc,則打印出由字符a,b,c所能排列出來的所有字符串abc,acb,bac,bca,cab和cba。

**輸入：**輸入一個字符串,長度不超過9(可能有字符重復),字符只包括大小寫字母。

**思路：**通過將第k位的字符提取到最前面，然后進行和后面的每個字符進行交換，得到所有結果集。

# -*- coding:utf-8 -*- class Solution:def Permutation(self, ss):# write code hereif not ss:return []res=[]self.helper(ss,res,'')return sorted(list(set(res))) def helper(self,ss,res,path):if not ss:res.append(path)else:for i in range(0,len(ss)):self.helper(ss[:i]+ss[i+1:],res,path+ss[i])

if name==‘main’:
str=‘abbcDeefg’
str1=‘abbc’
solution=Solution()
ans=solution.Permutation(str1)
print(ans)

28.數組中出現次數超過一般的數字

**題目：**數組中有一個數字出現的次數超過數組長度的一半，請找出這個數字。例如輸入一個長度為9的數組{1,2,3,2,2,2,5,4,2}。由于數字2在數組中出現了5次，超過數組長度的一半，因此輸出2。如果不存在則輸出0

**題解：**利用list列表來存放每個數出現的次數ans[numbers[i]]=ans[numbers[i]]+1。

# -*- coding:utf-8 -*- class Solution:def MoreThanHalfNum_Solution(self, numbers):# write code herenumlen=len(numbers)halflen=numlen//2maxans=0ans=[0 for i in range(0,1000)]for i in range(0,len(numbers)):ans[numbers[i]]=ans[numbers[i]]+1if ans[numbers[i]]>maxans:maxans=numbers[i]ans.sort()ans.reverse()res=ans[0]if res>halflen:return maxanselse:return 0

if name==‘main’:
num=list(map(int,input().split(’,’)))
solution=Solution()
ans=solution.MoreThanHalfNum_Solution(num)
print(ans)

29.最小的K個數

**題目：**輸入n個整數，找出其中最小的K個數，例如輸入4,5,1,6,2,7,3,8這8個數字，則最小的4個數字是1,2,3,4。

# -*- coding:utf-8 -*- class Solution:def GetLeastNumbers_Solution(self, tinput, k):# write code hereif k>len(tinput):return []tinput.sort()return tinput[:k]

if name==‘main’:
num=list(map(int,input().split(’,’)))
k=int(input())
solution=Solution()
ans=solution.GetLeastNumbers_Solution(num,k)
print(ans)

30.連續子數組的最大和

**題目：**HZ偶爾會拿些專業問題來忽悠那些非計算機專業的同學。今天測試組開完會后,他又發話了:在古老的一維模式識別中,常常需要計算連續子向量的最大和,當向量全為正數的時候,問題很好解決。但是,如果向量中包含負數,是否應該包含某個負數,并期望旁邊的正數會彌補它呢？例如:{6,-3,-2,7,-15,1,2,2},連續子向量的最大和為8(從第0個開始,到第3個為止)。你會不會被他忽悠住？(子向量的長度至少是1)

# -*- coding:utf-8 -*- class Solution:def FindGreatestSumOfSubArray(self, array):# write code heremaxsum,tempsum=array[0],array[0]for i in range(1,len(array)):if tempsum<0:tempsum=array[i]else:tempsum = tempsum + array[i]if tempsum>maxsum:maxsum=tempsumreturn maxsum

if name==‘main’:
array=list(map(int,input().split(’,’)))
solution=Solution()
ans=solution.FindGreatestSumOfSubArray(array)
print(ans)

31.整數中1出現的次數

**題目：**求出1_{13的整數中1出現的次數,并算出100}1300的整數中1出現的次數？為此他特別數了一下1~13中包含1的數字有1、10、11、12、13因此共出現6次,但是對于后面問題他就沒轍了。ACMer希望你們幫幫他,并把問題更加普遍化,可以很快的求出任意非負整數區間中1出現的次數（從1 到 n 中1出現的次數）。

**思路：**對每個數字的每位進行分解，含有1則結果加1。

# -*- coding:utf-8 -*- class Solution:def NumberOf1Between1AndN_Solution(self, n):# write code hereans=0for i in range(1,n+1):tempans=0while i!=0:eachnum=i%10i=i//10if eachnum==1:tempans=tempans+1ans=ans+tempansreturn ans

if name==‘main’:
n=130
solution=Solution()
ans=solution.NumberOf1Between1AndN_Solution(n)
print(ans)

32.把數組排成最小的數

**題目：**輸入一個正整數數組，把數組里所有數字拼接起來排成一個數，打印能拼接出的所有數字中最小的一個。例如輸入數組{3，32，321}，則打印出這三個數字能排成的最小數字為321323。

**思路：**將數組轉換成字符串之后，進行兩兩比較字符串的大小，比如3,32的大小由332和323確定，即3+32和32+3確定。

# -*- coding:utf-8 -*- class Solution:def PrintMinNumber(self, numbers):# write code hereif not numbers:return ""num = map(str, numbers)for i in range(0,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=''for i in range(0,len(numbers)):ans=ans+str(numbers[i])return ans

if name==‘main’:
numbers=[3,32,321]
solution=Solution()
ans=solution.PrintMinNumber(numbers)
print(ans)

33.丑數

**題目：**把只包含質因子2、3和5的數稱作丑數（Ugly Number）。例如6、8都是丑數，但14不是，因為它包含質因子7。習慣上我們把1當做是第一個丑數。求按從小到大的順序的第N個丑數。

**思路：**每一個丑數必然是由之前的某個丑數與2，3或5的乘積得到的，這樣下一個丑數就用之前的丑數分別乘以2，3，5，找出這三這種最小的并且大于當前最大丑數的值，即為下一個要求的丑數。

# -*- coding:utf-8 -*- class Solution:def GetUglyNumber_Solution(self, index):# write code hereif (index <= 0):return 0uglyList = [1]indexTwo = 0indexThree = 0indexFive = 0for i in range(index-1):newUgly = min(uglyList[indexTwo]*2, uglyList[indexThree]*3, uglyList[indexFive]*5)uglyList.append(newUgly)if (newUgly % 2 == 0):indexTwo += 1if (newUgly % 3 == 0):indexThree += 1if (newUgly % 5 == 0):indexFive += 1return uglyList[-1]

if name==‘main’:
solution=Solution()
index=200
ans=solution.GetUglyNumber_Solution(index)
print(ans)

34.第一個只出現一次的字符

**題目：**在一個字符串(0<=字符串長度<=10000，全部由字母組成)中找到第一個只出現一次的字符,并返回它的位置, 如果沒有則返回 -1。

**思路：**找出所有出現一次的字符，然后進行遍歷找到第一次出現字符的位置。

# -*- coding:utf-8 -*- class Solution:def FirstNotRepeatingChar(self, s):# write code hereif not s:return -1sset=set(s)dict={}for c in sset:dict[c]=0for i in range(0,len(s)):dict[s[i]]=dict[s[i]]+1onetime=[]for c in dict:if dict[c]==1:onetime.append(c) if onetime is None:return -1else:index=0for i in range(0,len(s)):if s[i] in onetime:index=ibreakreturn index

if name==‘main’:
s=‘abbddebbac’
solution=Solution()
ans=solution.FirstNotRepeatingChar(s)
print(ans)

35.數組中的逆序對

**題目描述：**在數組中的兩個數字，如果前面一個數字大于后面的數字，則這兩個數字組成一個逆序對。輸入一個數組,求出這個數組中的逆序對的總數P。并將P對1000000007取模的結果輸出。即輸出P%1000000007。

**輸入描述：**題目保證輸入的數組中沒有的相同的數字。

數據范圍：
對于%50的數據,size<=10^4
對于%75的數據,size<=10^5
對于%100的數據,size<=2*10^5

示例1

輸入 1,2,3,4,5,6,7,0

輸出 7

# -*- coding:utf-8 -*- class Solution:def InversePairs(self, data):# write code hereglobal countcount = 0 def A(array):global countif len(array) <= 1:return arrayk = int(len(array) / 2)left = A(array[:k])right = A(array[k:])l = 0r = 0result = []while l < len(left) and r < len(right):if left[l] < right[r]:result.append(left[l])l += 1else:result.append(right[r])r += 1count += len(left) - lresult += left[l:]result += right[r:]return resultA(data)return count % 1000000007

if name==‘main’:
data=[1,2,3,4,5,6,7,0]
solution=Solution()
ans=solution.InversePairs(data)
print(ans)

36.兩個鏈表的第一個公共節點

**題目：**輸入兩個鏈表，找出它們的第一個公共結點。

# -*- coding:utf-8 -*- class ListNode:def __init__(self, x):self.val = xself.next = None class Solution:def FindFirstCommonNode(self, pHead1, pHead2):# write code herelist1 = []list2 = []node1 = pHead1node2 = pHead2while node1:list1.append(node1.val)node1 = node1.nextwhile node2:if node2.val in list1:return node2else: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=B5C6=ListNode(6) C7=ListNode(7)A3.next=C6 B5.next=C6 C6.next=C7solution=Solution() ans=solution.FindFirstCommonNode(A1,B4) print(ans.val)

37.數字在排序數組中出現的次數

**題目：**統計一個數字在排序數組中出現的次數。

# -*- coding:utf-8 -*- class Solution:def GetNumberOfK(self, data, k):# write code hereans=0for i in range(0,len(data)):if data[i]==k:ans=ans+1if data[i]>k:breakreturn 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.二叉樹的深度

**題目：**輸入一棵二叉樹，求該樹的深度。從根結點到葉結點依次經過的結點（含根、葉結點）形成樹的一條路徑，最長路徑的長度為樹的深度。

# -*- coding:utf-8 -*- class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = None

class Solution:
def TreeDepth(self, pRoot):
# write code here
if pRoot is None:
return 0
left=self.TreeDepth(pRoot.left)
right=self.TreeDepth(pRoot.right)
print(left,right)
return max(left,right)+1

if name==‘main’:

總結

以上是生活随笔為你收集整理的剑指offer-python解答的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：事实感知的生成式文本摘要
下一篇：陈华钧 | 知识图谱构建，将成为智能金融