• LeetCode第一题 两数之和


    2021年3月4日

    两数之和

    给定一个整数数组 nums和一个整数目标值 target ,请你在该数组中找出和为目标值的那两个整数,并返回他们的数组下标。

    你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。(这个使用两遍,7和7=14 时不行的这个就输出[n.n]这种,当时我的理解时,这个数组内的数只能用一次,就是遍历一次就已经用过一次了。这种想法)

    你可以按照任意顺序返回答案;

    示例1

    输入:nums =[2,7,11,15],target=9

    输出:[0,1]

    解释:因为 nums[0] + nums[1] ==9 ,返回 [0, 1];

    实例2:

    输入:nums =[3,2,4], target=6

    输出: [1,2]

    实例3:

    输入:nums = [3,3], target =6

    输出:[0,1]

    提示:

      2<=mums.length<=10^3

      -10^9<=nums[i] <=10^9

      -10^9<=target<=10^9

      只会存在一个有效答案

    自己思路:

    首先想到的是用循环遍历 ok,写下

    public class Solution_01 {
    
        public static int[] twoSum(int[] nums, int target) {
            int[] result = new int[2];
            for (int i = 0; i < nums.length - 1; i++) {// 先来个顶点索引
                for (int j = 1; j < nums.length; j++) {// 除了第一个素组,一次擦找对应匹配对,
                    if (target == (nums[i] + nums[j])) {
                        result[0] = i;
                        result[1] = j;
                        return result;// 匹配成功返回
                    }
                }
            }
            return result;
        }

    问题是解决的一半

    (后续)上面的代码优化 j=nums.length-1,这样循环就有少了点次数(精彩)。

    别人家的孩子代码:

        public static int[] twoSum(int[] nums, int target) {
            // 注重实际情况,先判断检查一下
            if (nums == null || nums.length == 0)
                return new int[0];
            // 先来个顶点索引
            for (int i = 0; i < nums.length; i++) {
                int x = nums[i];
                // 在其后顶点查找,线性查找
                for (int j = i + 1; j < nums.length; j++) {
                    if (nums[j] == target - x) {
                        return new int[] { i, j };
                    }
                }
            }
            return new int[0];
        }

    空间复杂度:因为不开辟空间,所以空间复杂度为o(1)

    时间复杂度:需要计算那个语句的最多执行的次数  0(n^2)

    时间复杂度技术:(n-1)+ n(n-2)+...+1

    在次优化:不用线性查O(n)找用二分查找o(log n)

    思路:如果用二分找,就发现下标就会重新排序,虽然值时一样的,但是下标却变了。

    所以要开辟空间用map<内容值,数组下标值>。解决了排序后还能找到以前数组的对应下标

    空间复杂度:开辟空间O(n)

    时间复杂度:O(nlog n)

    复习 二分查找(折半查找):

    二分查找要求线性表必须采用顺序存储结构,而且表中元素按关键字有序排列。

    再次优化用hash查找

    复习下 hashMap

    public static int[] twoSum1(int[] nums, int target) {
            // 注重实际情况,先判断检查一下
            if (nums == null || nums.length == 0)
                return new int[0];
            // 数据先处理下 第一个疑惑:这时不是就用了一次(重复值问题)
            HashMap<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) { // 0(n)
    
                map.put(nums[i], i);
            }
            for (int i = 0; i < nums.length; i++) {// O(n)
                int x = nums[i];
                // 哈希查找 0(1)
                if (map.containsKey(target - x)) {
                    int index = map.get(target - x);
                    // i和index不是同一个元素,同一个元素不能使用两次
                    if (i != index)
                        return new int[] { i, index };
                }
    
            }
    
            return new int[0];
        }

    最终的答案:

        public static int[] twoSum2(int[] nums, int target) {
            // 注重实际情况,先判断检查一下
            if (nums == null || nums.length == 0)
                return new int[0];
            // 数据先处理下 第一个疑惑:这时不是就用了一次(重复值问题)
            HashMap<Integer, Integer> map = new HashMap<>();
    
            for (int i = 0; i < nums.length; i++) {// O(n)
                int x = nums[i];
                // 哈希查找 0(1)
                if (map.containsKey(target - x)) {
                    int index = map.get(target - x);
                    // i和index不是同一个元素,同一个元素不能使用两次
                    // if (i != index)//不用这个的原因是后添加的数根本就不会检测到重复的数值(下标索引是否重复)
    
                    return new int[] { i, index };
                }
                map.put(x, i);
    
            }
    
            return new int[0];
        }

     

  • 相关阅读:
    层叠
    属性值的计算过程
    HTML+CSS笔记1-杂
    C语言—栈
    C语言零碎知识点
    线性表,顺序表,链表,数组的区别与联系
    C语言—单链表
    转载——从机器学习谈起
    readonly和const关键字
    C#中的扩展方法
  • 原文地址:https://www.cnblogs.com/wanghlblog/p/14478143.html
Copyright © 2020-2023  润新知