Question

我正在解决一个问题（代码35）。我的代码针对测试用例返回null 输入：[1,3,5,6]，7。找不到错误。

给出排序后的数组和目标值，如果找到目标，则返回索引。如果不是，则返回按顺序插入索引的位置。

您可以假定数组中没有重复项。

Example 1:

Input: [1,3,5,6], 5
Output: 2
Example 2:

Input: [1,3,5,6], 2
Output: 1
Example 3:

Input: [1,3,5,6], 7
Output: 4
Example 4:

Input: [1,3,5,6], 0
Output: 0

在我的代码下面。我知道这个问题有许多不同的解决方案，而我的解决方案也不是最优的。但请帮助我了解错误的位置，而不是提供全新的解决方案。谢谢！

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        try:
            return nums.index(target)
        except:
            for i in range(len(nums)):
                print i
                if nums[i] - target > 0:
                    return i
                else: 
                    print "hello", len(nums)
                    return len(nums)

Answer 1

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if target in nums:
            return (nums.index(target))
        else:
            nums.append(target)
            nums.sort()
            return(nums.index(target))

Answer 2

您的第一部分是正确的，使用list.index并捕获异常。但是您的第二部分（没有印刷品）

  for i in range(len(nums)):
      if nums[i] - target > 0:
          return i  # return if True
      else: 
          return len(nums)  # return if False

这意味着for循环的第一次迭代无论如何都将始终返回。

您需要将else块带出for循环；像这样的东西：

def searchInsert(self, nums, target):
    try:
        return nums.index(target)
    except IndexError:  # best to use explicit except
        for index, value in enumerate(nums):  # more pythonic than range(len(nums))
             if value > target:
                  return index
        return len(nums)

Answer 3

如果for循环中的else错误，则应将else置于for循环之外。

from multiprocessing_generator import ParallelGenerator
import multiprocessing.dummy, multiprocessing_generator

# Monkey-patch to use threads
multiprocessing_generator.Process = multiprocessing.dummy.Process
multiprocessing_generator.Queue = multiprocessing.dummy.Queue

但是，bisect已经包含了您所需的一切。

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        try:
            return nums.index(target)
        except:
            for i in range(len(nums)):
                print i
                if nums[i] - target > 0:
                    return i

            print "hello", len(nums)
            return len(nums)

作为练习，您可以尝试再次执行此练习，而无需使用索引，您可能要使用枚举和其他条件。

Answer 4

检查一下！

class Solution:
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        nums.append(target)         
        nums.sort()                 
        for i,j in enumerate(nums): 
            if target == j:         
                return i

Answer 5

您的解决方案的时间复杂度为O(n)，虽然还不错，但是如果我们使用O(log n)，我们可以获得更好的性能binary search。

class Solution:
  def searchInsert(self, array: List[int], target: int) -> int:
      low = 0
      high = len(array)

      while low < high:
          middle = (high + low) // 2

          if array[middle] == target:
              return middle

          if array[middle] < target:
             low = middle + 1

          if array[middle] > target:
             high = middle - 0
    return low

Answer 6

Javascript 的解决方案

var searchInsert = function(nums, target) {
    let l = 0;
    let r = nums.length - 1;
    let middle = Math.floor((r + l) / 2);
    if (nums[l] > target) return 0;
    if (nums[r] < target) return r + 1;
    while (nums[middle] !== target && l < r) {
        if (nums[middle] < target) {
            l = middle + 1;
        } else {
            r = middle;
        }
        middle = Math.floor((r + l) / 2);
    }
    return middle;
};

搜索插入位置

6 个答案: