学习不易、这里是总结看过的算法题哟、虽然大部分都看不懂、但是还是坚持看一下解题过程。。。力扣

两数之和

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

示例：

1
2
3
4
给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

题解：

当然、最暴力的方法就是双重循环遍历来判断、但是性能较低。最开始还是看不懂的、之和看了解题过程才明白的、我是fw。然而这里是循环遍历数组、target获取另一个数、判断Map中是否有这个数、有就通过数组返回 Map 中对应值的下标 和 当前索引、没有就把当前数组值和索引放入Map中、继续循环。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
*/ 
var twoSum = function (nums, target) {
    // 创建一个用于存放数组值和数组下标的Map集合
    var tempMap = new Map()
    // 循环遍历数组
    for (var i = 0; i < nums.length; i++) {
        // 通过 target 获取 另一个值
        var ontherNum = target - nums[i]
        // 判断Map中是否存在
        if (tempMap.has(ontherNum)) {
            // 存在就返回 Map 中对应值的下标 和 当前索引
            return [tempMap.get(ontherNum), i]
        }
        // 不存在就把当前数组值和索引放入Map中
        tempMap.set(nums[i], i)
    }
}

console.log(twoSum([2, 7, 11, 15], 9)) // [0, 1]

两数相加

题目：给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

1
2
3
输入: (2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 0 -> 8
原因: 342 + 365 = 807

题解：

我们可以简单化一个链表的模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var l1 = {
    val: 2,
    next: {
        val: 4,
        next: {
            val: 3,
            next: null
        }
    }
}

var l2 = {
    val: 5,
    next: {
        val: 6,
        next: {
            val: 4,
            next: null
        }
    }
}

。。。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
* function ListNode(val) {
*    this.val = val;
*    this.next = null;
* }
*/
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
*/
var addTwoNumbers = function (l1, l2) {
    // c1、c2 指向l1、l2 的头、c3为l3的头、l3为最后返回的链表
    var c1 = l1, c2 = l2, c3, l3, carry = 0;
    while (c1 || c2 || carry) {
        var v1 = 0; // 用来存放l1节点的val
        var v2 = 0; // 用来存放l2节点的val
        var sum = 0; // 节点 l1 l2 和 进位carry 之和 
        if (c1) {
            v1 = c1.val; // 获取值
            c1 = c1.next; // 指向下一个节点
        }
        if (c2) {
            v2 = c2.val;
            c2 = c2.next;
        }
        sum = v1 + v2 + carry; // 计算和
        //向下取整
        carry = Math.floor(sum / 10) // 取出当前数的 十位 
        if (!c3) { // 当链表不存在时 
            l3 = new ListNode(sum % 10) 
            c3 = l3
        } else {
            c3.next = new ListNode(sum % 10)
            c3 = c3.next
        }
    }
    return l3
}

无重复字符的最长子串

题目：给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

1
2
3
输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例 2:

1
2
3
输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例 3:

1
2
3
4
输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

题解：

力扣解法图： https://pic.leetcode-cn.com/202ea5bd4d4ba4a21afafdf52a9ea2556ba6265c1576840f09ace50aafab095c.png

这道题的思路就是用一个数组arr临时存放s中的字符、循环遍历s是判断当前字符是否存在于arr中、存在就获取下标并删除包括当前下标之前的值、再将当前字符添加进去、最后比较maxLength和arr的长度去最大值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var lengthOfLongestSubstring = function (s) {
    var arr = []
    var maxLength = 0;
    for (let item of s) {
        if (arr.includes(item)) {
            let index = arr.indexOf(item)
            arr.splice(0, index + 1)
        }
        arr.push(item)
        maxLength = Math.max(maxLength, arr.length)
    }
    return maxLength
}

console.log(lengthOfLongestSubstring("pwwpwe")); // 3