算法练习（哈希）

Posted 2022-09-26 小小菜_v

哈希

BM50 两数之和

描述 给出一个整型数组 numbers 和一个目标值 target，请在数组中找出两个加起来等于目标值的数的下标，返回的下标按升序排列。
（注：返回的数组下标从1开始算起，保证target一定可以由数组里面2个数字相加得到）

数据范围：2≤len(numbers)≤10^5 ，−10≤numbers i ​ ≤10 ^9 ，0≤target≤10^9 要求：空间复杂度 O(n)，时间复杂度 O(nlogn)

示例1
输入：[3,2,4],6
返回值：[2,3]
说明：因为 2+4=6 ，而 2的下标为2 ， 4的下标为3 ，又因为 下标2 < 下标3 ，所以返回[2,3]  
          
示例2
输入：[20,70,110,150],90
返回值：[1,2]
说明：20+70=90 

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param numbers int整型一维数组
# @param target int整型
# @return int整型一维数组
#


class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        # write code here
        index_list = []
        # for i in range(len(numbers) - 1):
        #     for j in range(i + 1, len(numbers)):
        #         n_sum = numbers[i] + numbers[j]
        #         if n_sum == target:
        #             index_list = [i + 1, j + 1]
        #             return index_list

        hash= dict()
        for i in range(len(numbers)):
            temp = target - numbers[i]
            if temp not in hash:
                hash[numbers[i]] = i
            else:
                index_list.append(hash[temp] + 1)
                index_list.append(i + 1)

        return index_list

BM51 数组中出现次数超过一半的数字

描述 给一个长度为 n 的数组，数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。

数据范围：n≤50000，数组中元素的值 0≤val≤10000
要求：空间复杂度：O(1)，时间复杂度 O(n)O输入描述： 保证数组输入非空，且保证有解

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

示例2
输入：[3,3,3,3,2,2,2]
返回值：3

示例3
输入：[1]
返回值：1

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

BM52 数组中只出现一次的两个数字

描述 一个整型数组里除了两个数字只出现一次，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

数据范围：数组长度2≤n≤1000，数组中每个数的大小0<val≤1000000 要求：空间复杂度 O(1)，时间复杂度 O(n)

提示：输出时按非降序排列。

示例1
输入：[1,4,1,6]
返回值：[4,6]
说明：返回的结果中较小的数排在前面  
   
示例2
输入：[1,2,3,3,2,9]
返回值：[1,9]

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param array int整型一维数组 
# @return int整型一维数组
#
class Solution:
    def FindNumsAppearOnce(self , array: List[int]) -> List[int]:
        # write code here
        hash = dict()
        for i in array:
            if i in hash:
                del hash[i]
            else:
                hash[i] = 1
        data = []
        for key, value in hash.items():
            if value == 1:
                data.append(key)
        
        return sorted(data)

BM53 缺失的第一个正整数

描述 给定一个无重复元素的整数数组nums，请你找出其中没有出现的最小的正整数

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

数据范围:
-2^31≤nums[i]≤2 ^31 −1
0≤len(nums)≤5∗10 ^5

示例1
输入：[1,0,2]
返回值：3

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

示例3
输入：[4,5,6,8,9]
返回值：1

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

BM54 三数之和

描述 给出一个有n个元素的数组S，S中是否有元素a,b,c满足a+b+c=0？找出数组S中所有满足条件的三元组。

数据范围：0≤n≤1000，数组中各个元素值满足 ∣val∣≤100
空间复杂度：O(n^2)，时间复杂度 O(n^2)

注意： 三元组（a、b、c）中的元素必须按非降序排列。（即a≤b≤c） 解集中不能包含重复的三元组。 例如，给定的数组 S = -10 0 10 20 -10 -40,解集为(-10, -10, 20),(-10, 0, 10)

示例1
输入：[0]
返回值：[]

示例2
输入：[-2,0,1,1,2]
返回值：[[-2,0,2],[-2,1,1]]

示例3
输入：[-10,0,10,20,-10,-40]
返回值：[[-10,-10,20],[-10,0,10]]

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
#
# @param num int整型一维数组
# @return int整型二维数组
#
class Solution:
    def threeSum(self, num: List[int]) -> List[List[int]]:
        # write code here
        hash = dict()
        if len(num) < 3:
            return []
        for i in range(len(num)):
            for j in range(i+1, len(num)):
                for k in range(j+1, len(num)):
                    res = num[i] + num[j] + num[k]
                    list_new = sorted([num[i], num[j], num[k]])
                    if res not in hash:
                        hash[res] = [list_new]
                    elif list_new in hash[res]:
                        continue
                    else:
                        hash[res].append(list_new)
        if 0 in hash:
            return sorted(hash[0])
        return []