找工作-体能修复8-编程-剑指offer-JZ3、JZ4、JZ5、JZ7、JZ8、JZ9、JZ10、JZ11、JZ12、JZ13、JZ14

于 2022-11-07 15:55:08 发布
阅读量233 收藏
点赞数
分类专栏： 算法 文章标签： leetcode 算法 职场和发展 python 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyyidiaodiao/article/details/127728510
版权

JZ3 数组中重复的数字

描述

在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组[2,3,1,0,2,5,3]，那么对应的输出是2或者3。存在不合法的输入的话输出-1


数据范围：0 \leqslant n \leqslant 10000
进阶：时间复杂度 O(n)，空间复杂度O(n)

示例1

输入： [2,3,1,0,2,5,3]
返回值：2
说明：2或3都是对的

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param numbers int整型一维数组 
# @return int整型
#
class Solution:
    def duplicate(self , numbers: List[int]) -> int:
        # write code here
        for i in numbers:
            if numbers.count(i)>=2:
                 return i
        return -1

自测结果

运行结果

 

JZ4 二维数组中的查找

描述

在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
[
[1,2,8,9],
[2,4,9,12],
[4,7,10,13],
[6,8,11,15]

]
给定 target = 7，返回 true。
给定 target = 3，返回 false。

数据范围：矩阵的长宽满足 5000 \leqslant n,m \leqslant 500 ， 矩阵中的值满足0\leqslant val\leqslant109
进阶：空间复杂度 O(1)，时间复杂度 O(n+m)

示例1

输入：7,[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
返回值：true
说明：存在7，返回true

示例2

输入：1,[[2]]
返回值：false

示例3

输入：3,[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]
返回值：false
说明：不存在3，返回false

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param target int整型 
# @param array int整型二维数组 
# @return bool布尔型
#
class Solution:
    def Find(self , target: int, array: List[List[int]]) -> bool:
        # write code here
        for i in array:
            if target in i :
                return True
        return False

自测结果

 

运行结果

JZ5 替换空格

描述

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


数据范围: 0\leqslant len(s)\leqslant1000 。保证字符串中的字符为大写英文字母、小写英文字母和空格中的一种。

示例1

输入："We Are Happy"
返回值："We%20Are%20Happy"

示例2

输入：" "
返回值："%20"

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param s string字符串 
# @return string字符串
#
class Solution:
    def replaceSpace(self , s: str) -> str:
        # write code here
        results = ''
        for i in s:
            if i == " ":
                results +="%20"
            else:
                results +=i
        return results

自测结果

 

运行结果

JZ7 重建二叉树

描述

给定节点数为 n 的二叉树的前序遍历和中序遍历结果，请重建出该二叉树并返回它的头结点。
例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建出如下图所示。

 

提示:

1.vin.length == pre.length

2.pre 和 vin 均无重复元素

3.vin出现的元素均出现在 pre里

4.只需要返回根结点，系统会自动输出整颗树做答案对比

数据范围： n\leqslant 2000，节点的值 (\displaystyle -10000) \leqslant val\leqslant 10000

要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1

输入：[1,2,4,7,3,5,6,8],[4,7,2,1,5,3,8,6]
返回值：{1,2,3,4,#,5,6,#,7,#,#,8}
说明：返回根节点，系统会输出整颗二叉树对比结果，重建结果如题面图示

 

示例2

输入：[1],[1]
返回值：{1}

示例3

输入：[1,2,3,4,5,6,7],[3,2,4,1,6,5,7]
返回值：{1,2,5,3,4,6,7}

代码

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pre int整型一维数组 
# @param vin int整型一维数组 
# @return TreeNode类
#
class Solution:
    def reConstructBinaryTree(self , pre: List[int], vin: List[int]) -> TreeNode:
        # write code here
        if not pre:
            return None
        root = TreeNode(pre[0])
        tmp = vin.index(pre[0])
        root.left = self.reConstructBinaryTree(pre[1:tmp+1], vin[:tmp])
        root.right = self.reConstructBinaryTree(pre[tmp+1:], vin[tmp+1:])
        return root

自测结果

  运行结果

 

JZ8 二叉树的下一个结点

描述

给定一个二叉树其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的next指针。下图为一棵有9个节点的二叉树。树中从父节点指向子节点的指针用实线表示，从子节点指向父节点的用虚线表示

 

示例

输入:{8,6,10,5,7,9,11},8

返回:9

解析:这个组装传入的子树根节点，其实就是整颗树，中序遍历{5,6,7,8,9,10,11}，根节点8的下一个节点就是9，应该返回{9,10,11}，后台只打印子树的下一个节点，所以只会打印9，如下图，其实都有指向左右孩子的指针，还有指向父节点的指针，下图没有画出来

数据范围：节点数满足 1\leqslant n\leqslant 50 ，节点上的值满足 1\leqslant val\leqslant 100

要求：空间复杂度 O(1) ，时间复杂度 O(n)

输入描述：

输入分为2段，第一段是整体的二叉树，第二段是给定二叉树节点的值，后台会将这2个参数组装为一个二叉树局部的子树传入到函数GetNext里面，用户得到的输入只有一个子树根节点

返回值描述：

返回传入的子树根节点的下一个节点，后台会打印输出这个节点

示例1

输入：{8,6,10,5,7,9,11},8 
返回值：9

示例2

输入：{8,6,10,5,7,9,11},6 
返回值：7

示例3

输入：{1,2,#,#,3,#,4},4 
返回值：1

示例4

输入：{5},5 
返回值："null" 
说明：不存在，后台打印"null"

代码

# -*- coding:utf-8 -*-
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        # write code here
        if pNode.right:
            rchild = pNode.right
            while rchild.left:
                rchild = rchild.left
            return rchild
        while pNode:
            if pNode.next:
                if pNode.next.left == pNode:
                    return pNode.next
                pNode = pNode.next
            else:
                return None

自测结果

 

 运行结果

JZ9 用两个栈实现队列

描述

用两个栈来实现一个队列，使用n个元素来完成 n 次在队列尾部插入整数(push)和n次在队列头部删除整数(pop)的功能。 队列中的元素为int类型。保证操作合法，即保证pop操作时队列内已有元素


数据范围：n\leqslant 1000
要求：存储n个元素的空间复杂度为 O(n) ，插入与删除的时间复杂度都是O(1)

示例1

输入：["PSH1","PSH2","POP","POP"]
返回值：1,2

说明："PSH1":代表将1插入队列尾部 "PSH2":代表将2插入队列尾部 "POP“:代表删除一个元素，先进先出=>返回1 "POP“:代表删除一个元素，先进先出=>返回2

示例2

输入：["PSH2","POP","PSH1","POP"] 
返回值：2,1

代码

版本一

# -*- coding:utf-8 -*-
class Solution:
    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:
            while len(self.stack1)!=0:
                self.stack2.append(self.stack1.pop())
        value= self.stack2.pop()
        return value

版本二

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
    def push(self, node):
        # write code here
        self.stack1.append(node)
    def pop(self):
        # return xx
        return self.stack1.pop(0)

自测结果

运行结果

JZ10 斐波那契数列

描述

大家都知道斐波那契数列，现在要求输入一个正整数 n ，请你输出斐波那契数列的第 n 项。
斐波那契数列是一个满足 fib(x)=\left\{ \begin{array}{ll} 1&x=1,2 \\ fib(x-1)+fib(x-2)&x>2\end{array} \right. 的数列
数据范围： 1\leqslant n\leqslant 40
要求：空间复杂度 O(1) ，时间复杂度O(n) ，本题也有时间复杂度 O(logn) 的解法

输入描述：

一个正整数n

返回值描述：

输出一个正整数。

示例1

输入：4
返回值：3

说明：根据斐波那契数列的定义可知，fib(1)=1,fib(2)=1,fib(3)=fib(3-1)+fib(3-2)=2,fib(4)=fib(4-1)+fib(4-2)=3，所以答案为3。

示例2

输入：1
返回值：1

示例3

输入：2
返回值：1

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param n int整型 
# @return int整型
#
class Solution:
    def Fibonacci(self , n: int) -> int:
        # write code here
        a = 1 # n-1
        b = 1 # n-2
        c = 1 # n 
        for i in range(3, n+1):
            c = a+b # fib(n)=fib(n-1)+fib(n-2)
            b = a   
            a = c   
        return c

自测结果

 运行结果

JZ11 旋转数组的最小数字

描述

有一个长度为 n 的非降序数组，比如[1,2,3,4,5]，将它进行旋转，即把一个数组最开始的若干个元素搬到数组的末尾，变成一个旋转数组，比如变成了[3,4,5,1,2]，或者[4,5,1,2,3]这样的。请问，给定这样一个旋转数组，求数组中的最小值。


数据范围： 1\leqslant n\leqslant10000 ，数组中任意元素的值： 0\leqslant val\leqslant10000

要求：空间复杂度： O(1) ，时间复杂度： O(logn)

示例1

输入：[3,4,5,1,2]
返回值：1

示例2

输入：[3,100,200,3]
返回值：3

代码

1.数组为空
2.部分旋转，例如由（1,2,3,4,5）旋转为（3,4,5,1,2），此时只需要遍历数组，找到当前数比前面的数小的数即可。
3.完全旋转，例如由（1,2,3,4,5）旋转为（1,2,3,4,5），此时第一个数最小。
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param rotateArray int整型一维数组 
# @return int整型
#
class Solution:
    def minNumberInRotateArray(self , rotateArray: List[int]) -> int:
        # write code here
        if len(rotateArray) == 0:
            return -1
        for i in range(len(rotateArray)-1):
            if rotateArray[i] > rotateArray[i+1]:
                return rotateArray[i+1]
        return rotateArray[0]

自测结果

 运行结果

JZ12 矩阵中的路径

描述

请设计一个函数，用来判断在一个n乘m的矩阵中是否存在一条包含某长度为len的字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如[[a, b, c, e], [s, f, c, s], [a, d, e, e]]矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
数据范围：0\leqslant n,m \leqslant20 , 1\leqslant len\leqslant 25

示例1

输入：[[a,b,c,e],[s,f,c,s],[a,d,e,e]],"abcced"
返回值：true

示例2

输入：[[a,b,c,e],[s,f,c,s],[a,d,e,e]],"abcb"
返回值：false

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param matrix char字符型二维数组 
# @param word string字符串 
# @return bool布尔型
#
class Solution:
    def hasPath(self , matrix: List[List[str]], word: str) -> bool:
        # write code here
        if len(matrix) == 0:
            return False
        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if self.backtrack(matrix, word,0,i,j):
                    return True
        return False
    

    def backtrack(self, matrix, word, index, i, j):
        if index == len(word):
            return True
        if i < 0 or i >= len(matrix) or j < 0 or j >= len(matrix[0]) or (matrix[i][j]!=word[index]):
            return False
        temp = matrix[i][j]
        matrix[i][j] = '*'
        if (self.backtrack(matrix,word,index+1,i+1,j)
        or self.backtrack(matrix,word,index+1,i,j+1)
        or self.backtrack(matrix,word,index+1,i-1,j)
        or self.backtrack(matrix,word,index+1,i,j-1)):
            return True
        matrix[i][j] = temp
        return False

自测结果

运行结果

JZ13 机器人的运动范围

描述

地上有一个 rows 行和 cols 列的方格。坐标从 [0,0] 到 [rows-1,cols-1] 。一个机器人从坐标 [0,0] 的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于 threshold 的格子。 例如，当 threshold 为 18 时，机器人能够进入方格 [35,37] ，因为 3+5+3+7 = 18。但是，它不能进入方格 [35,38] ，因为 3+5+3+8 = 19 。请问该机器人能够达到多少个格子？


数据范围：0\leqslant threshold\leqslant 15， 1\leqslant rows,cols\leqslant 100


进阶：空间复杂度 O(nm) ，时间复杂度 O(nm)

示例1

输入： 1,2,3
返回值：3

示例2

输入： 0,1,3 
返回值：1

示例3

输入： 10,1,100
返回值：29

说明： [0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],[0,10],[0,11],[0,12],[0,13],[0,14],[0,15],[0,16],[0,17],[0,18],[0,19],[0,20],[0,21],[0,22],[0,23],[0,24],[0,25],[0,26],[0,27],[0,28] 这29种，后面的[0,29],[0,30]以及[0,31]等等是无法到达的

示例4

输入： 5,10,10
返回值：21

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param threshold int整型 
# @param rows int整型 
# @param cols int整型 
# @return int整型
#
class Solution:
    def movingCount(self, threshold, rows, cols):
        # write code here
        self.rows = rows
        self.cols = cols
        self. dict = set()
        self.dfs(threshold, 0, 0)
        return len(self.dict)

        
    def sum(self, i, j):
        sum = (i//10)+(i%10)+(j//10)+(j%10)
        return sum

    def dfs(self,threshold, i,j):
        if (not self.sum(i,j) <= threshold) or (i,j) in self.dict:
            return 
        self.dict.add((i,j))
        if i != self.rows-1:
            self.dfs(threshold, i+1, j)
        if j != self.cols-1:
            self.dfs(threshold, i, j+1)

自测结果

 运行结果

JZ14 剪绳子

描述

给你一根长度为 n 的绳子，请把绳子剪成整数长的 m 段（ m 、 n 都是整数， n > 1 并且 m > 1 ， m <= n ），每段绳子的长度记为 k[1],...,k[m] 。请问 k[1]*k[2]*...*k[m] 可能的最大乘积是多少？例如，当绳子的长度是 8 时，我们把它剪成长度分别为 2、3、3 的三段，此时得到的最大乘积是 18 。


数据范围：2\leqslant n\leqslant 60
进阶：空间复杂度 O(1)，时间复杂度 O(n)

输入描述：

输入一个数n，意义见题面。

返回值描述：

输出答案。

示例1

输入：8
返回值：18

说明：8 = 2 +3 +3 , 2*3*3=18

示例2

输入：2
返回值：1

说明：m>1，所以切成两段长度是1的绳子

代码

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param number int整型 
# @return int整型
#
class Solution:
    def cutRope(self , number: int) -> int:
        # write code here
        if number < 2:
            return 0
        elif number == 2:
            return 1
        elif number == 3:
            return 2
        else:
            x = number % 3
            y = number // 3
            if x == 0:
                res=3**y
            elif x == 1:
                res=3**(y-1)*4
            else:
                res=3**y*2
            return res

自测结果

 

 运行结果

游客26024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《剑指offer》题解
程序人生
12-25 433
1.赋值运算符函数 CMyString&amp; CMyString::operator=(const CMyString &amp;str) { if (this != &amp;str) { CMyString strTemp(str); char *pTemp = strTemp.m_pData; strTemp.m_pDa...
剑指 Offer 题解（JeanCheng）
12-24
剑指 Offer 题解（JeanCheng） 剑指 Offer 题解（JeanCheng）
每日一题之二叉树
m0_50290125的博客
11-24 294
描述 给定一个二叉树其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的next指针。下图为一棵有9个节点的二叉树。树中从父节点指向子节点的指针用实线表示，从子节点指向父节点的用虚线表示 示例: 输入:{8,6,10,5,7,9,11},8 返回:9 解析:这个组装传入的子树根节点，其实就是整颗树，中序遍历{5,6,7,8,9,10,11}，根节点8的下一个节点就是9，应该返回{9,10,11}，后台只打印子树的下一个节点，所以只
剑指 offer 题目分析及答案
熊仙森滴Blog
09-03 4410
1. 前言 2. 实现 Singleton 3. 数组中重复的数字 4. 二维数组中的查找 5. 替换空格 6. 从尾到头打印链表 7. 重建二叉树 8. 二叉树的下一个结点 9. 用两个栈实现队列 10.1 斐波那契数列 10.2 跳台阶 10.3 矩形覆盖 10.4 变态跳台阶 11. 旋转数组的最小数字 12. 矩阵中的路径 13. 机器人的运动范围 14. 剪绳子 15. 二进制中 ...
剑指offer【题解】
GZbiubiubiu的博客
06-20 305
数组中重复的数字 题目描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。 解法一 来源：牛客网回答区 思路 循环遍历数组，给数组下标为当前元素的...
Leetcode刷题记录
aruihuang的博客
03-08 286
主要记录个人认为的重点题，作为总结。范围覆盖剑指offer、HOT100。 剑指offer 43. 1~n中整数1出现的次数 输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。 例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。 示例 1： 输入：n = 12 输出：5 示例 2： 输入：n = 13 输出：6 限制： 1 <= n ...
行业文档-设计装置-壁式体能训练器.zip
08-21
壁式体能训练器是一种常见的健身设备，常用于健身房、体育场馆及家庭健身空间，旨在提供多样化的训练方式，以提升用户的体能素质。在这个"行业文档-设计装置-壁式体能训练器.zip"压缩包中，包含了一个名为"壁式体能...
行业分类-设备装置-移动式体能训练方舱.zip
09-05
移动式体能训练方舱是一种集成了多种训练设备和功能的可移动训练设施，主要用于提升个人或团队的身体素质。在IT行业中，虽然不直接涉及硬件或软件开发，但这种装置的信息化管理和智能化应用却与IT技术密切相关。以下...
行业文档-设计装置-便携式体能疲劳恢复装置.zip
08-22
3. 激光治疗模块：采用低强度激光照射，刺激细胞代谢，提高组织修复速度，有助于肌肉损伤的恢复。 4. 功能性电刺激模块：通过电极向肌肉发送微弱电流，模拟自然神经冲动，促使肌肉被动收缩和舒张，达到锻炼和放松的...
行业分类-设备装置-一种滚筒式体能训练装置.zip
08-20
本文将围绕“滚筒式体能训练装置”这一主题，深入探讨其设计原理、功能特点以及在体能训练中的应用。 滚筒式体能训练装置是一种创新的健身器材，它结合了机械力学和人体工学原理，旨在提升用户的体能水平，包括力量...
剑指offer题解（Java版）
12-27
剑指offer题解，使用Java实现，整理自牛客网，QQ交流群：419927514
剑指 offer 题解.pdf
09-13
剑指 offer 题解.pdf
剑指offer答案全集解析
11-04
剑指offer答案全集解析
剑指offer题解
踏地仰望
02-25 208
算法是程序员能力的重要体现，学习和工作中要注意锻炼算法能力。 计划分专题完成该本书的题目 一、数组类型 1、数组中的重复数字 题目：在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复...
剑指Offer题解
小龙的博客
06-27 535
二维数组中的查找 题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 题解 class Solution { public: bool Find(int target, vector<vector<int&...
剑指Offer题解（Python版）
不要怕
01-23 380
5.从头到尾打印链表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值