ARTS Week 2

Algorithm

本周的 LeetCode 题目为 1. 两数之和

题目简介

给定一个整数数组 nums 和一个整数目标值 target，找出该数组中和为目标值 target 的那两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

示例 ：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

题目思路

题目的思路很简单，遍历数组，查找 target - nums[0] 是否在数组 nums 中，若在返回 0 和它的下标，若不在，查找下一个，即 target-nums[1] 是否在数组中，直至找到停止。为了快速查找 target-nums[i]，可以记录下数组中的 值——索引 的对应关系。

最终代码

// 自己的写法
class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, HashSet<Integer>> numIndexMap = new HashMap<Integer, HashSet<Integer>>();
        for (int i = 0; i < nums.length; i++) {
            Integer num = nums[i];
            if (numIndexMap.containsKey(num) == false) {
                numIndexMap.put(num, new HashSet<Integer>());
                numIndexMap.get(num).add(i);
            } else {
                numIndexMap.get(num).add(i);
            }
        }
        int[] ans = new int[2];
        int index = 0;
        for (Integer key: numIndexMap.keySet()) {
            Integer goalKey = target - key;
            if (goalKey.equals(key) == true) {
                if (numIndexMap.get(goalKey).size() > 1) {
                    for (Integer temp: numIndexMap.get(goalKey)) {
                        ans[index] = temp;
                        index += 1;
                    }
                }
            } else {
                if (numIndexMap.containsKey(goalKey) == true) {
                    for (Integer temp: numIndexMap.get(key)) {
                        ans[0] = temp;
                    }
                    for (Integer temp: numIndexMap.get(goalKey)) {
                        ans[1] = temp;
                    }
                }
            }
        }
        return ans;
    }
}

但自己的写法较为复杂，官方的写法简略。实际上没有必要为每个元素都建立值—索引的映射关系，可以等到遍历的时候进行判断和建立。代码如下:

// 官方的写法
class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> numIndexMap = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            if (numIndexMap.containsKey(target - nums[i])) {
                return new int[]{numIndexMap.get(target - nums[i]), i};
            } else {
                numIndexMap.put(nums[i], i);
            }
        }
        return new int[2];
    }
}

Review

本周 Review 的英文文章为：Follow boring advice。

这篇文章很短，作者分享了一些建议，这些建议在作者眼中是无聊枯燥的，我认为大部分是老调重谈。虽说其中很多相信大部分人早已听过，但做到却并不是那么容易，这就是知易行难。Review 这篇文章，一是希望能对大家有帮助，二是希望能提醒自己。

下面的就是作者分享的具体建议：

• 行动(Action)：无论什么事，先做起来。我们是由我们所做的事决定的，而不是所想的事定义的。任何不完美的行动都比一直思考它更好；
• 连贯(Consistency)：好事是建立在一个好习惯并在坚持它的过程中发生。如定期锻炼身体；
• 迭代(Iteration)：需要不时地停下来，反思，调整继续前进。一味地做而不去反思可能会在错误的道路上越走越远；
• 复利(Compounding)：复利不仅适用于金融领域，同样也适用于生活中，每个细微的改变也会随着时间推移产生巨大影响；
• 刻意练习(Deliberate practice)：如果想要提高某项能力，重要的是有意识的刻意训练它；
• 专注(Focus)：一次只做一件事，设立明确的目标，避免分心和冲动；
• 分治法(Divide and conquer)：将一个大的任务分割成一个个小的任务来完成；
• 积极乐观和感激(Positivity and gratitude)：对生活要保持积极乐观，对生活中的人要怀有感激之心。

Tip

快慢指针判断条件的细微差异。

快慢主要用在链表中，简单的说快慢指针就是慢指针一次只前进一步，而快指针一次会前进两步，这样快指针的就会先达到 null 后，停止循环。示例代码如下：

/**
 * Definition for singly-linked list.
 * 单链表定义
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */

ListNode slow = head;
ListNode fast = head;
while (判断条件) {
	slow = slow.next;
	fast = fast.next.next;
}

判断条件有两种选择，分别为：

• (fast != null) && (fast.next != null)
• (fast.next != null) && (fast.next.next != null)

当判断条件是 (fast != null) && (fast.next != null) ，结束时慢指针所在的位置正好是后半部分的开始位置。示例如下：

1->2->3->4->5->null
s  s  s  s
f     f     f  f->end

1->2->3->4->null
s  s  s
f     f     f->end

而当判断条件是 (fast.next != null) && (fast.next.next != null) ，结束时慢指针后半部分的开始位置的前一个，即正中间的位置（总个数为奇数）或者是前半部分的最后一个（总个数为偶数）。示例如下：

1->2->3->4->5->null
s  s  s
f     f     f->end

1->2->3->4->null
s  s
f     f->end

Share

连续四个月在朋友圈和QQ空间分享月度总结，可以基本视为养成了习惯。虽说并没有会带来特别大的改变，但还是收获了不少，也感受到了一定的提升。每个评论的、点赞的人都可以视为监督者，感谢他们起到了监督自己、鞭策自己的作用，没有他们自己很可能会在某些方面上会放纵一些。