Algorithm

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

解题思路：

先对这个数组进行排序，怎么找出不重复的元素比较关键，之前想把符合的3个元素中的前两项存起来，然后每次去查询，当然集合选择的是hash类型，但是执行后，超过了例子的执行时间，说明效率还是很低，后来苦思冥想，终于想到了最佳的方式去查看重复元素，就是做标记，既然是排好序的，遍历哪一层，只要和之前遍历的前一层元素重复，那就没必要往后执行了，直接跳出循环，当然了，我一直在怎么存储思考打转，还可以从怎么遍历思考进行优化

public static List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> list = new LinkedList<>();
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }
        Integer a = null;
        for (int i = 0; i < nums.length - 2; i++) {
            if (a!=null&&a == nums[i]) {
                continue;
            }

            Integer b = null;
            for (int j = i + 1; j < nums.length - 1; j++) {
                if (b!=null &&b == nums[j]) {
                    continue;
                }
                Integer index = map.get(0 - nums[i] - nums[j]);
                if (index != null && index > j) {
                    List<Integer> threeList = new LinkedList<>();
                    threeList.add(nums[i]);
                    threeList.add(nums[j]);
                    threeList.add(nums[index]);
                    list.add(threeList);
                }
                b = nums[j];
                continue;
            }
            a = nums[i];
        }
        return list;
    }

Review

redis官方实现Redis分布式锁

Tip

最近看了网络基础，原来vlan就是对一个广播域lan进行拆分，说白了就是交换机的网络隔离。

Share

Redis分布式锁的实现demo

String LOCK = "lock";
        while (true) {
            RLock lock = redisson.getLock(LOCK);
            boolean isLock = false;
            try {
                isLock = lock.tryLock(500, 1500, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (isLock) {
                try {
                    //业务代码
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                    //如果某个线程超时了，自动释放锁，在解锁时会抛出异常，可以捕获这个异常进行回滚操作
                }
            } else {
                long end = System.currentTimeMillis();
                if (end - begin > 300000) {
                   //如果超时，进行业务处理
                }
                continue;
            }
            break;
        }