【LeetCode with Python】 Two Sum

博客域名: http://www.xnerv.wang
原题页面: https://oj.leetcode.com/problems/two-sum/
题目类型:两点问题
难度评价:★★★
本文地址: http://blog.csdn.net/nerv3x3/article/details/37339471

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2


给定一个数列(注意不一定有序),和一个指定的数值target。从这个数列中找出两个数相加刚好等于target,要求给出这两个数的下标(注意数列下标是从1而不是从0开始)。
首先将数列排序。由于最后要得求的是两个数的原有下标,而不是两个数本身,因此要用一个新的对象Item来封装原有数列元素,并记录该元素的原有下标。排序是针对数列元素本身数值的,分别用一个index1指针和一个index2指针指向排序后的数列的首位,如果指向的两个数相加的和等于target,则搜索结束;如果和小于target,则由于index2此时指向的已经是数组中的最大数了,因此只能令index1向右移动一次;如果和大于target,则由于此时index1已经指向数组中的最小数了,因此只能令index2向左移动一次。用一个循环重复上述过程,直到和等于target宣告搜索成功,或者index1>=index2宣告搜索失败。
空间复杂度O(n),因为构造了一个新的Item序列。时间复杂度方面,如果假设Python的sort算法是用的快速排序的话,那排序的时间复杂度为O(n*logn),搜索过程的时间复杂度为O(n),因此总的时间复杂度为O(n*logn)。
注意给的数列也许长度为0,这样无论target是多少都是搜索失败。而且题目中给的example明显是是在误导人,不仔细看误以为数列原本就有序。此外,数列下标是从1而不是从0开始的。
但是这种算法的前提要先进行一次排序,看起来总是有点不舒服,是不是有更好的算法呢?

class Solution:

    class Item:
        def __init__(self, value, index):
            self.value = value
            self.index = index

    # @return a tuple, (index1, index2)
    def twoSum(self, num, target):
        len_num = len(num)
        if 0 == len_num:
            return (-1, -1)

        items = [Solution.Item(value, 0) for value in num]
        for i in range(0, len_num):
            items[i].index = i + 1
        items.sort(lambda x, y: cmp(x.value, y.value))
        index1 = 0
        index2 = len_num - 1
        is_find = False
        while index1 < index2:
            total = items[index1].value + items[index2].value
            if total < target:
                index1 += 1
            elif total > target:
                index2 -= 1
            else:
                is_find = True
                break
        (index1, index2) = (index1, index2) if items[index1].index <= items[index2].index else (index2, index1)
        return (items[index1].index, items[index2].index) if is_find else (-1, -1)
### 回答1: LeetCode是一个优秀的在线编程平台,提供了丰富的算法和数据结构题目供程序员练习。其中的简单题大多可以用Python语言编写,下面为您提供几个常见题目的Python版本答案。 1. 两数之和(Two Sum) 题目描述:给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。 Python版本答案: class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: d = {} for i, x in enumerate(nums): if target - x in d: return [d[target - x], i] d[x] = i 2. 反转字符串(Reverse String) 题目描述:编写一个函数,其作用是将输入的字符串反转过来。 Python版本答案: class Solution: def reverseString(self, s: List[str]) -> None: """ Do not return anything, modify s in-place instead. """ left, right = 0, len(s) - 1 while left < right: s[left], s[right] = s[right], s[left] left += 1 right -= 1 3. 回文数字(Palindrome Number) 题目描述:判断一个整数是否是回文数,例如:121是回文数,-121不是回文数。 Python版本答案: class Solution: def isPalindrome(self, x: int) -> bool: if x < 0: return False if x == 0: return True str_x = str(x) left, right = 0, len(str_x) - 1 while left < right: if str_x[left] != str_x[right]: return False left += 1 right -= 1 return True 以上只是这几个简单题目的Python版本答案,实际上LeetCode上还有很多其他编程语言编写的优秀答案,需要程序员们自己去探索和实践。 ### 回答2: Leetcode是一个流行的在线编程题库,提供了许多关于算法和数据结构的题目,难度从简单到困难不等。Python是一种易学易用的编程语言,备受程序员欢迎。因此,许多程序员使用Python来解决Leetcode的编程问题。下面我将提供一些Python版本的Leetcode简单题的答案。 1. 两数之和 题目描述:给定一个整数数组和一个目标值,在数组中找到两个数之和等于目标值。 解题思路:使用哈希表来存储数组中每个元素的值和索引,然后遍历每个元素时,查找目标值减去当前元素的值是否在哈希表中,如果存在,返回两个值的索引。 Python代码: def twoSum(nums, target): hash_table = {} for i, num in enumerate(nums): complement = target - num if complement in hash_table: return hash_table[complement], i hash_table[num] = i nums = [2, 7, 11, 15] target = 9 print(twoSum(nums, target)) # Output: (0, 1) 2. 路径总和 题目描述:给定一棵二叉树和一个目标值,判断是否存在从根节点到叶节点的路径,使得路径上所有节点的值相加等于目标值。 解题思路:遍历二叉树的所有路径,判断路径上所有节点的值相加是否等于目标值。 Python代码: class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def hasPathSum(root, sum): if not root: return False if not root.left and not root.right and root.val == sum: return True return hasPathSum(root.left, sum - root.val) or hasPathSum(root.right, sum - root.val) root = TreeNode(5) root.left = TreeNode(4) root.right = TreeNode(8) root.left.left = TreeNode(11) root.left.left.left = TreeNode(7) root.left.left.right = TreeNode(2) root.right.left = TreeNode(13) root.right.right = TreeNode(4) root.right.right.right = TreeNode(1) sum = 22 print(hasPathSum(root, sum)) # Output: True 3. 最大子序和 题目描述:给定一个整数数组,找到一个具有最大和的子数组,返回该子数组的和。 解题思路:使用动态规划,定义状态dp[i]表示以第i个数结尾的最大子数组和,则状态转移方程为dp[i] = max(dp[i-1] + nums[i], nums[i])。 Python代码: def maxSubArray(nums): if not nums: return 0 n = len(nums) dp = [0] * n dp[0] = nums[0] for i in range(1, n): dp[i] = max(dp[i-1] + nums[i], nums[i]) return max(dp) nums = [-2,1,-3,4,-1,2,1,-5,4] print(maxSubArray(nums)) # Output: 6 总结:以上是三个Python版本的Leetcode简单题的答案,它们涉及到哈希表、二叉树、动态规划等算法和数据结构。这些题目既考验了程序员的基本功,又是训练算法思维的好工具。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值