java把double数组转换成float数组_Python Leetcode(数组）

83 阅读 0 评论 55 点赞

我是靠谱客的博主落后钢铁侠，最近开发中收集的这篇文章主要介绍java把double数组转换成float数组_Python Leetcode(数组），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1、26. 删除排序数组中的重复项

解法1：两个指针i，j；j不断往后走和已确定的数比较，看是否在其中。

解法2：将数组转换成这样一个字典，key是数，values是对应的个数，keys组成的数组就是需要得到的结果。

#由于题目给的是有序数组，所以可计算每个元素的个数，然后直接选取组成新的数组，当然是在原来是数组的内存上

这里给出几个将数组转换成各种字典的代码块：

#如何实现一组数据转换成字典形式,key是值，value是索引

2、删除排序数组中的重复项

解法1：利用上一题的解法2，但是本题不只是返回一个长度，还要改变原数组的值

class

3、35搜索插入位置

本题得到的启发是一些无关的代码不需要，代码简洁用时和占用内存都会少，此题主要就是二分，找不到就插入，什么情况找不到呢，就是low>high,此时low就是要插入的位置

class

4、53最大子序列和

解法1：动态规划：dp[i]中存的是以nums[i]作为最后一个元素的子序列，和最大的子序列存在两种情况，1.只有一个元素nums[i]；2.不止一个元素，此时和为dp[i-1]+nums[i],由此得到：

状态转移方程： dp[i] = max{A[i], dp[i-1]+A[i]}

数组dp[]的最大值就是最大子序列和。

class

解法2：分治

#分治

6、66加一

class

7、88合并两个有序数组

class

8、118杨辉三角

class

9、杨辉三角2

class

10、121买股票最佳时机1

记录两个值，最小的股票价格和最大的利润

class Solution:
    def maxProfit(self, nums: List[int]) -> int:
        minprice=float('inf')
        maxprofit=0
        for i in range(len(nums)):
            if minprice>nums[i]:
                minprice=nums[i]
            elif maxprofit<(nums[i]-minprice):
                maxprofit=(nums[i]-minprice)
        return maxprofit

11、买股票最佳时机2

开始降的时候卖出：nums[i]>nums[i-1] and nums[i]>=nums[i+1]

开始升的时候买入：nums[i]<=nums[i-1] and nums[i]<nums[i+1]

考虑到连续值相同的情况，边界情况需要细细考虑

class

12、167. 两数之和 II - 输入有序数组

双指针，一个指头，一个指尾，若两者和等于target返回索引，若小于i+1，大于则j-1

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        i=0
        j=len(nums)-1    
        while i<j:
            if nums[i]+nums[j]==target:
                return (i+1,j+1)
            elif nums[i]+nums[j]<target:
                i=i+1
            else:
                j=j-1

13、169多数元素

14、189旋转数组

虽然通过，但是时间复杂度和空间复杂度很高

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        for i in range(k): 
            a=nums[-1]
            nums[1:]=nums[:-1]
            nums[0]=a

15、217存在重复元素

方法1：记录每个元素的个数

class

方法2：将数组转为集合，从长度比较出发

class

16、219、存在重复元素2

方法1 ：建立字典，key是元素，value是元素的各个索引；对于字典的每个键值对，找value列表相邻元素的差，如果差小于K,则找到并中断，否则继续往下找，直至所有元素找完

class

17、268、缺失数字

边界情况，最左边数字和最右边数组不在数组内直接返回

一般情况，中间缺失

class Solution:
    def missingNumber(self, nums: List[int]) -> int:

        if 0 not in nums:
            return 0
        if len(nums) not in nums:
            return len(nums)
        nums.sort()
        flag=0
        for i in range(len(nums)-1):
            if (nums[i+1]-nums[i])!=1:
                flag=1
                return (nums[i]+1)
        if flag==0:
            return len(nums)

18、283移动0

本题主要用到了切片

for i in range((ll-1),-1,-1):

nums[-1:-(ll+1):-1]

class

19、414第三大的数

set()时间复杂度

class

20、448 找到所有数组中消失的数字

class

21、485最大连续1的个数

class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        ml=0
        cl=0
        for i in nums:
            if i==1:
                cl=cl+1
                if ml<cl:
                    ml=cl
            else:
                cl=0
        return ml

22、509. 斐波那契数

class

23、561. 数组拆分 I

class

24、532. 数组中的K-diff数对

两个集合，s1和s2,s1存访问过的数，s2存K-diff对中较小的数

nums

25、566. 重塑矩阵

自己写的效率不高

class

26、643. 子数组最大平均数 I

class

27、628. 三个数的最大乘积

class

28、697. 数组的度

class Solution:
    def findShortestSubArray(self, a: List[int]) -> int:
        left={}
        right={}
        count={}

        for index,val in enumerate(a):
            if val not in left:
                left[val]=index
            right[val]=index
            count[val]=count.get(val,0)+1

        degree=max(count.values())
        ll=len(a)
        for i in count:
            if count[i]==degree:
                ll=min(ll,right[i]-left[i]+1)
        return ll

#下面这个用时久些
class Solution:
    def findShortestSubArray(self, a: List[int]) -> int:
        H={}
        for index,val in enumerate(a):
            if val not in H:
                H[val]=1
            else:
                H[val]+=1

        v=max(list(H.values()))
        k=[]
        for i in H:
            if H[i]==v:
                k.append(i)
        left={}
        right={}
        l=len(a)
        for i in range(l):
            j=i+1
            if a[i] in k:
                left[a[i]]=i
            if a[-j] in k:
                right[a[-j]]=l-j
        left=sorted(left.items(), key=lambda d:d[0])
        right=sorted(right.items(), key=lambda d:d[0])

        minl=l
        for i in range(len(left)):
            m=left[i][1]-right[i][1]
            if m<minl:
                minl=m
        return minl+1

29、674. 最长连续递增序列

方法1：各个上升子序列是互不相交的，所以记录每次突变的点其实就是记录上升子序列的开始位置，计算出相邻开始位置的差，保留差的最大值，由于最后一个上升z子序列没有终点，需要单独考虑其长度，并判断这个长度和之前那些最大长度的大小，取最大值

方法2：动态规划，最主要的是找出状态转移方程，dp[i]表示位置i的连续递增子序列长度，初始化为1，因为每个数字是最小的递增子序列，状态转移方程：若nums[i-1]<nums[i]，则dp[i]=dp[i-1]+1；否则dp[i]=1

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        l=len(nums)
        if l==0:
            return 0
        dp=[1 for i in range(l)]
        re=1
        for i in range(1,l):
            if nums[i]>nums[i-1]:
                dp[i]=dp[i-1]+1
                re=max(re,dp[i])
        return re