leetcode - 刷题记录-探索中级算法-排序和搜索

颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        
        n_0 = 1 if nums[0] == 0 else 0
        for i in range(1,len(nums)):
            print(i,nums[i],nums)
            if nums[i]==2:
                continue
            if nums[i]==1:
                nums[n_0+1:i+1] = nums[n_0:i]
                nums[n_0] = 1
            if nums[i]==0:
                nums[1:i+1] = nums[0:i]
                nums[0] = 0
                n_0 += 1

通过

前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        if len(nums) == k:
            return nums
        dic = {}
        for i in nums:
            if i in dic:
                dic[i]+=1
            else:
                dic[i]=1
        fre = []
        res = []
        for i in dic:
            if len(res)<k:
                fre.append(dic[i])
                res.append(i)
            elif dic[i] > min(fre):
                ind = fre.index(min(fre))
                res[ind] = i
                fre[ind] = dic[i]
        return res

通过

数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        if k < int(len(nums)*0.5):
            # k largest
            for i in range(k):
                for j in range(1,len(nums)):
                    if nums[j] < nums[j-1]:
                        nums[j],nums[j-1] = nums[j-1],nums[j]
                res = nums[-1]
                nums = nums[:-1]
            return res
        else:
            k = len(nums) - k + 1
            for i in range(k):
                for j in range(1,len(nums)):
                    if nums[j] > nums[j-1]:
                        nums[j],nums[j-1] = nums[j-1],nums[j]
                res = nums[-1]
                nums = nums[:-1]
            return res

通过

寻找峰值
1. 峰值元素是指其值大于左右相邻值的元素。
  
  给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。
  
  数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。
  
  你可以假设 nums[-1] = nums[n] = -∞。
2. ```
class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        
        nums.append(float(-inf))
        nums = [float(-inf)] + nums
        for i in range(1,len(nums)-1):
            tmp = nums[i-1:i+2] 
            if tmp[1] > tmp[0] and tmp[1]>tmp[2]:
                return i-1
```
  通过

在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        # 二分查找
        if len(nums) == 0:
            return [-1,-1]
        if target < nums[0] or target > nums[-1]:
            return [-1,-1]
        elif target == nums[0]:
            i = 0
            while i<len(nums)-1 and nums[i+1] == target:
                i = i+1
            return [0,i]
        elif target == nums[-1]:
            i = len(nums)-1
            while i>1 and nums[i-1] == target:
                i = i-1
            return [i,len(nums)-1]
        else:
            s = 0
            e = len(nums)-1
            while s<=e:
                mid = int(0.5*(s+e))
                if nums[mid] == target:
                    i = mid
                    j = mid
                    while i>=1 and nums[i-1] == target:
                        i = i-1
                    while j<=len(nums)-1 and nums[j+1] == target:
                        j = j+1
                    return [i,j]
                elif nums[mid] > target:
                    e = mid-1
                    while s<e and nums[e-1] == nums[e]:
                        e = e-1
                else:
                    s = mid+1
                    while s<e and nums[s+1] == nums[s]:
                        s = s+1
            return [-1,-1]

通过

合并区间
1. 给出一个区间的集合，请合并所有重叠的区间。
搜索旋转排序数组
1. 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
  
  ( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
  
  搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
  
  你可以假设数组中不存在重复的元素。
  
  你的算法时间复杂度必须是 O(log n) 级别。
2. ```
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        dic = dict(zip(nums,range(len(nums))))
        try:
            return dic[target]
        except:
            return -1
```
  这道题应该是用二分查找做的，这里做的不对。
搜索二维矩阵 II
1. 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：
  1. 每行的元素从左到右升序排列。
  2. 每列的元素从上到下升序排列。

qq_32110859

发布了45 篇原创文章 · 获赞 1 · 访问量 8552

私信关注

leetcode - 刷题记录-探索中级算法-排序和搜索

猜你喜欢