剑指offer python刷题

最新推荐文章于 2024-06-09 23:06:21 发布

Egozjuer

最新推荐文章于 2024-06-09 23:06:21 发布

阅读量1.2k

点赞数 1

本文链接：https://blog.csdn.net/weixin_42494287/article/details/82252566

版权

1、二维数组的查找

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        for line in array:
            if target in line:
                return True
        return 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)

题目描述

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

# -*- coding:utf-8 -*-
class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        # write code here
        temp=s.replace(" ","%20")
        return temp
if __name__=="__main__":
    s="We Are Happy"
    ans=Solution().replaceSpace(s)
    print(ans)

3.从尾到头打印链表

题目描述

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

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

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        # write code here
        l=list()
        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=A5

    solution=Solution()
    ans=solution.printListFromTailToHead(A1)
    print(ans)

4 重建二叉树

题目描述

https://blog.csdn.net/Datawhale/article/details/81948283

https://blog.csdn.net/z2539329562/article/details/79875642

可以用来参考

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

解题思路

思路1

前序遍历的第一个值一定为根节点，对应于中序遍历中间的一个点。在中序遍历序列中，这个点左侧的均为根的左子树，这个点右侧的均为根的右子树。
利用递归，分别取前序遍历[1:i+1]和中序遍历的[:i]对应与左子树继续上一个过程，取前序遍历[i+1:]和中序遍历[i+1:]对应于右子树继续上一个过程，最终得以重建二叉树。
i是中序序列中pre(0)所在位置，也就是中序序列中根的位置

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        # write code here
        if len(pre)==0:
            return None
        elif len(pre)==1:
            return TreeNode(pre[0])
        else:
            root=TreeNode(pre[0])
            root.left=self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
            root.right=self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
        return root

5 反转链表

输入一个链表，反转链表后，输出新链表的表头。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.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看成self._head
            temp=pHead.next
            #让pHead指向了pre，第一次迭代时，pre=None
            pHead.next=pre
            #让pre记录原来表头的地址
            pre=pHead
            #temp赋值给新表头
            pHead=temp
        return pre

6 链表中环的入口节点

题目：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

思路：采用遍历的方式，将遍历链表的结果放入列表，如果某一次加入的node已经存在链表中，则返回该node

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution:
    def EntryNodeOfLoop(self, pHead):
        # write code here
        #pHead==self._head
        cur=pHead
        list=[]
        while cur!=None:
            if cur in list:
                return cur
            else:
                list.append(cur)
                cur=cur.next
        return None

7 合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

 -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.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)):
            pre.next=ListNode(ans[i])
            pre=pre.next
        return head

8 用两个栈实现队列

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

申请两个栈Stack1和Stack2，Stack1当作输入，Stack2当作pop。当Stack2空的时候，将Stack1进行反转，并且输入到Stack2。

class Solution:
    def __init__(self):
        self.stack1=[]
        self.stack2=[]
    def push(self, node):
        # write code here 
        return self.stack1.append(node)
    def pop(self):
        # return xx
        if 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())"""

入队：将元素进栈A

出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；

如果不为空，栈B直接出栈。

9 旋转数组的最小数字：

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{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 here
        minum=9999
        for i in range(len(rotateArray)):
            if minum>rotateArray[i]:
                minum=rotateArray[i]
        if minum:
            return minum
        else:
            return 0

10 斐波那契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39


class Solution:
    def Fibonacci(self, n):
        # write code here
        a=[0,1,1]
        if n<3:
            return a[n]
        for i in range(3,n+1):
            a.append(a[i-1]+a[i-2])
        return a[n]

11 跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

比较倾向于找规律的解法，f(1) = 1, f(2) = 2, f(3) = 3, f(4) = 5，可以总结出f(n) = f(n-1) + f(n-2)的规律，但是为什么会出现这样的规律呢？假设现在6个台阶，我们可以从第5跳一步到6，这样的话有多少种方案跳到5就有多少种方案跳到6，另外我们也可以从4跳两步跳到6，跳到4有多少种方案的话，就有多少种方案跳到6，其他的不能从3跳到6什么的啦，所以最后就是f(6) = f(5) + f(4)；这样子也很好理解变态跳台阶的问题了。

class Solution:
    def jumpFloor(self, n):
        # write code here     
        a=[1,2]
        if n<3:
            return a[n-1]
        for i in range(3,n+1):
            a.append(a[i-2]+a[i-3])
        return a[n-1]


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

class Solution:
    # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result=[]
        while(matrix):
                result+=matrix.pop(0)
                if not matrix or not matrix[0]:
                       break
                matrix=self.turn(matrix)
        return result
    #把矩阵逆时针旋转90度
    def turn(self,matrix):
        c=len(matrix)
        r=len(matrix[0])
        d=[]
        for i in range(r):
            d.append([x[i] for x in matrix])
            d.reverse()
        return d

a, b = b, a+b

# 这种赋值，先计算等值右边那么 b=1 a+b=2

# 再赋值给a和b，那么 a=1, b=2

a = b

# 此时 b=1, 那么a=1

b = a+b

# 那么 b=2

a=2，b=4 与题意不符

12 变态跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

分析：因为n级台阶，第一步有n种跳法：跳1级、跳2级、到跳n级
跳1级，剩下n-1级，则剩下跳法是f(n-1)
跳2级，剩下n-2级，则剩下跳法是f(n-2)
所以f(n)=f(n-1)+f(n-2)+...+f(1)
因为f(n-1)=f(n-2)+f(n-3)+...+f(1)

所以f(n)=2*f(n-1) 实质是等比数列

class Solution:
    def jumpFloorII(self, number):
        # write code here
        if number<=0:
            return 0
        else:
            return pow(2,number-1)

13 矩形覆盖

题目描述

https://www.nowcoder.com/profile/719202/codeBookDetail?submissionId=11677929

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

class Solution:
    def rectCover(self, number):
        # write code here
        a=[0,1,2]
        if number<3:
            return a[number]
        for i in range(3,number+1):
            a.append(a[i-2]+a[i-1])
        return a[number]

通过实验发现f（1）=1 f（2）=2 f（3）=3 f（4）=5 得知是斐波那契数列

14 二进制中1的个数

题目描述

http://www.runoob.com/python/python-operators.html

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

>>右移运算符：

把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

a=0011 1100 a>>2 结果输出15 二进制解释 0000 1111

& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0

a = 0011 1100

b = 0000 1101

(a & b) 输出结果 12 ，二进制解释： 0000 1100

分析：每次进行左移一位，然后与1进行相与，如果是1则进行加1。

class Solution:
    def NumberOf1(self, n):
        # write code here
        count=0
        for i in range(32):
            count += (n >> i) & 1
        return count

15 数值的整数次方

题目描述

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

四种情况：base=0 ex=0 ex>0 ex<0

class Solution:
    def Power(self, base, exponent):
        # write code here
        ans=1
        if base==0:
            return False
        for i in range(0,abs(exponent)):
            ans=base*ans
        if exponent>0:
            return ans
        elif exponent==0:
            return 1
        else:
            return 1/ans

16 调整数组顺序使奇数位于偶数前面

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

分析：申请奇数数组和偶数数组，分别存放奇数值和偶数值，数组相加便为结果。

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

17 链表中倒数第K个节点

题目描述

输入一个链表，输出该链表中倒数第k个结点。

两种思路

（1）两个指针，都先指向头结点，先让第一个指针走K步，达到第K+1个节点

然后两个指针同时向后移，当第一个节点到达末尾时，第二个节点所在位置的下一个位置就是倒数第K个节点

for example

加入有五个节点，K=2，第一个节点front走了两步到达第三个节点，然后两个节点同时往后走，当front走到最后一个节点时，later节点在第三个节点的位置，需要继续向后前进一步，所以是later.next

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

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        front=head
        later=head
        for i in range(k):
        #链表为空集或者K的大小超过了链表的长度，都可以这么处理
            if front==None:
                return
        #链表只有一个节点的情况
            if front.next==None and i==k-1:
                return head
            front=front.next
        while front.next!=None:
            front=front.next
            later=later.next
        return later.next

(2) 遍历一遍链表，把链表添加进列表，然后使用L[-K]即可

class Solution:
    def FindKthToTail(self, head, k):
        # write code here
        l=[]
        while head!=None:
            l.append(head)
            head=head.next
        if k>len(l) or k<1:
            return
        return l[-k]

18 二叉数的镜像

递归的思想

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回镜像树的根节点
    def Mirror(self, root):
        # write code here
        if root!=None:
            root.left,root.right=root.right,root.left
            self.Mirror(root.right)
            self.Mirror(root.left)

19 顺时针打印矩阵

可以模拟魔方逆时针旋转的方法，一直做取出第一行的操作

例如

1 2 3

4 5 6

7 8 9

输出并删除第一行后，再进行一次逆时针旋转，就变成：

6 9

5 8

4 7

继续重复上述操作即可。

Python代码如下

class Solution:
    # matrix类型为二维列表，需要返回列表
         # matrix类型为二维列表，需要返回列表
    def printMatrix(self, matrix):
        # write code here
        result = []
        while(matrix):
            #取出矩阵的第一行
            result+=matrix.pop(0)
            if not matrix or not matrix[0]:
                break
            matrix = self.turn(matrix)
        return result
    #逆时针翻转矩阵
    def turn(self,matrix):
        num_r = len(matrix)
        num_c = len(matrix[0])
        newmat = []
        for i in range(num_c):
            newmat.append([x[i] for x in matrix])
        newmat.reverse()
        return newmat

Egozjuer

关注

1
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
剑指offer python刷题

1、二维数组的查找在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 class Solution: # array 二维列表 def Find(self, target, array): ...
复制链接

扫一扫