Leetcode | Somme de deux nombres Notes

1. La somme de deux nombres

Description des questions

Étant donné un tableau d'entiers numset une valeur cible entière , veuillez rechercher les deuxtarget entiers du tableau dont la somme est la valeur cible targetet renvoyer leurs indices de tableau.

Analyse du problème et mise en œuvre

Difficulté : [Facile]

Structure des données : tableau

Méthode de mise en œuvre de base :

• énumération par force brute
• méthode à double pointeur
• Méthode de table de hachage, etc.

Mise en œuvre 1 : Dénombrement violent

• Énumérez chaque numéro du tableau xet découvrez s'il existe dans le tableautarget - x
• Chaque élément ne peut pas être utilisé deux fois, il vous suffit donc de xrechercher dans les éléments suivantstarget - x

# Use Python to solve
def two_sum(nums: List[int], target:int) -> List[int]:
    '''
    使用暴力枚举法求两数之和
    
    参数:
        nums (list[int]): 包含整数的列表
        target(int): 目标和
    
	返回值:
    	list[int]: 包含两个索引的列表，这两个索引对应的元素之和等于目标和target如果没有找到符合条件的索引对，返回空列表[]

    '''
    arr_length = len(nums)    
    if not nums or arr_length < 2:
        return []
       
    # 使用暴力枚举法来一一确认符合条件的元素索引
    for i in range(arr_length):
        for j in range(i + 1, arr_length):
            if nums[i] = target - nums[j]
            	return [i, j]
            
    return []

Analyse de la complexité temporelle :

• Meilleur cas : si une paire d'index qualifiés est trouvée lors du premier parcours, la complexité temporelle est $O\left(1\right)$
• Dans le pire des cas : si aucune paire d'index correspondante n'est trouvée, deux niveaux de boucles doivent être complètement parcourus et la complexité temporelle est $O\left(n^2\right)$, où n estnumsla longueur de la liste
• Cas moyen : en moyenne, deux niveaux de boucles doivent être parcourus et la complexité temporelle est $O\left(n^2\right)$

Analyse de la complexité spatiale :

• Aucun espace supplémentaire n'est utilisé, seules des variables de niveau constant sont utilisées pour stocker les données, donc complexité spatiale : $O\left(1\right)$

Implémentation 2 : méthode du double pointeur

• Créer une liste (List) pour stocker les valeurs​​et index du tableau dans des tuples, et les trier (par valeur)
• Définissez les pointeurs gauche et droit, et lorsque le pointeur gauche est plus petit que le pointeur droit, effectuez un jugement de boucle
• Si la somme des valeurs des pointeurs gauche et droit est égale à la valeur cible, ajoutez son index à une nouvelle liste (num_list)

# Use Python to solve 
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        '''
        使用双指针方法解决两数之和

        参数：
            nums (list[int]): 整数数组
            target(int): 目标值            

        返回值：
            nums_list(list[int]): 和为目标值的两个整数的数组下标
        '''
        arr_length = len(nums)
        if not nums or arr_length < 2:
        	return []
        
        # 存放最终结果
        num_list = []  

        # 创建一个列表按(num, index)格式存放
        nums_with_index = [(num, index) for index, num in enumerate(nums)]
        # 对nums_with_index按照数字大小进行排序
        nums_with_index.sort()
        
        
        # 定义左右两个指针
        left, right = 0, arr_length - 1
        
        # 当左指针小于右指针时，进行循环
        while left < right:
            # 如果左指针和右指针所指数字的和等于目标值
            if nums_with_index[left][0] + nums_with_index[right][0] == target:               
                num_list.append(nums_with_index[left][1])
                num_list.append(nums_with_index[right][1])
                break
            # 如果左指针和右指针所指数字的和小于目标值
            elif nums_with_index[left][0] + nums_with_index[right][0] < target:
                # 左指针右移
                left += 1            
            else:
                # 右指针左移
                right -= 1
        
        return num_list

Analyse de la complexité temporelle :

• Meilleur scénario : si une paire de nombres correspondants est trouvée dans la première boucle, la complexité temporelle est $O\left(1\right)$
• Dans le pire des cas : si aucune paire de nombres correspondante n'est trouvée, la liste entière doit être parcourue et la complexité temporelle est $O\left(n\right)$ , où n estnums_with_indexla longueur de
• Cas moyen : en moyenne, la liste entière doit être parcourue et la complexité temporelle est $O\left(n\right)$

Analyse de la complexité spatiale :

• Un espace supplémentaire est créé : nums_with_index, donc la complexité de l'espace est $O\left(n\right)$

Implémentation 3 : table de hachage

• Créer une table de hachage pour un tableau
• Pour chacun d'entre eux x, nous demandons d'abord s'il existe dans la table de hachage target - x, puis xnous l'insérons dans la table de hachage, ce qui garantit qu'il ne correspondra pas xà lui-même.

# Use Python to solve 
def two_sum(nums: List[int], target: int) -> List[int]:
    '''
    使用哈希表方法解决两数之和问题
    
    参数:
        nums (list[int]): 包含整数的列表
        target (int): 目标和值
        
    返回值:
        List[int]: 包含两个索引的列表，这两个索引对应的元素之和等于目标和target如果没有找到符合条件的索引对，返回空列表[]
    '''
    arr_length = len(nums)
    if not nums or arr_length < 2:
        return []
    
    nums_map = {
    
    }  # 创建一个空的哈希表，用于存储数字和索引的映射关系
    
    for i, num in enumerate(nums):  # 遍历列表，同时获取数字的索引
        if target - num in nums_map:  # 如果target - num在哈希表中存在，说明之前出现过一个数字与当前num之和等于target
            return [nums_map[target - num], i]  # 返回之前记录的索引和当前索引
        nums_map[num] = i  # 将当前数字和索引添加到哈希表中
    
    return []  # 如果没有找到符合条件的索引对，返回空列表[]

Analyse de la complexité temporelle :

• Meilleur scénario : si une paire de nombres correspondants est trouvée dans le premier élément lors du parcours de la liste, la complexité temporelle est $O\left(1\right)$
• Dans le pire des cas : si aucune paire de nombres correspondante n'est trouvée, la liste entière doit être parcourue complètement et la complexité temporelle est $O\left(n\right)$ , où n estnumsla longueur de
• Cas moyen : en moyenne, la liste entière doit être parcourue et la complexité temporelle est $O\left(n\right)$

Analyse de la complexité spatiale :

• $O\left(n\right)$