第一题-因为这道题，临时调整计划，最后变成一道这种类型题

题目

nums1 中数字 x 的 下一个更大元素 是指 x 在 nums2 中对应位置 右侧 的 第一个 比 x ****大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足 nums1[i] == nums2[j] 的下标 j ，并且在 nums2 确定 nums2[j] 的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是 -1 。

返回一个长度为 nums1.length 的数组 **ans **作为答案，满足 **ans[i] **是如上所述的 下一个更大元素

示例：

输入： nums1 = [2,4], nums2 = [1,2,3,4].
输出： [3,-1]
解释： nums1 中每个值的下一个更大元素如下所述：
- 2 ，用加粗斜体标识，nums2 = [1,2,3,4]。下一个更大元素是 3 。
- 4 ，用加粗斜体标识，nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1

思路

1、暴力破解：遍历num1数组，然后循环num2数组查找num1[i]，找到后向后继续向后遍历，找到大于num[i]的num2[j]，找到就直接返回num2[j]的值塞进新的数组里，找不到返回-1塞进去-------不写了

代码小白，不配做栈、队列、数组、链表和红黑树啥的数据结构的题，臣妾做不到啊！！！！！下面是参考官方题解（一口老血喷出来，这是简单题）看个简单题还要看单调栈算法，喔！

代码

    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        Deque<Integer> stack = new ArrayDeque<Integer>();
        for (int i = nums2.length - 1; i >= 0; --i) {
            int num = nums2[i];
            while (!stack.isEmpty() && num >= stack.peek()) {
                stack.pop();
            }
            map.put(num, stack.isEmpty() ? -1 : stack.peek());
            stack.push(num);
        }
        int[] res = new int[nums1.length];
        for (int i = 0; i < nums1.length; ++i) {
            res[i] = map.get(nums1[i]);
        }
        return res;
    }

代码释义

我真的，这就是题解放在我眼前，我都不知道啥意思的那种，最终，走一遍代码，然后才理解的，不上释义了，直接写个自己走的路程吧

第二题

题目

给定一个数组 coordinates ，其中 coordinates[i] = [x, y] ， [x, y] 表示横坐标为 x、纵坐标为 y 的点。请你来判断，这些点是否在该坐标系中属于同一条直线上

思路

判断斜率是否一直相等就可以了，注意计算斜率的时候，不要忘记分母不能为0，单拎出来

代码

    public boolean checkStraightLine(int[][] coordinates) {
        boolean res = true;
        int num1 = coordinates[0][0];
        int num2 = coordinates[0][1];
        int num3 = coordinates[1][0];
        int num4 = coordinates[1][1];
        if(num3 - num1 == 0) {
            for(int i = 2; i < coordinates.length; i++) {
                if(coordinates[i][0] - num1 != 0) {
                    res = false;
                    break;
                };  
            }
        }else {
            double k = (double)((double)(num4 - num2)/(double)(num3-num1));
            for(int i = 2; i < coordinates.length; i++) {
                if((double)((double)(coordinates[i][1] - num2) / (double)(coordinates[i][0] - num1)) != k) {
                    res = false;
                    break;
                }
            }
        }
        return res;
    }

附加题

题目

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1

思路

竟然还加了个循环数组，我觉得我不配啊～

别问我怎么想出来的，我也不知道我怎么想出来的，我是试出来的，（要是别人这么告诉我也不信）

做的时候，感觉，啊，这！从哪开始循环啊，怎么判断啊，可能就是因为加了循环数组，所以，这道题是中等难度，我还是保留题目一的思想，比较难思考的就是循环的问题。

代码

    public int[] nextGreaterElements(int[] nums) {
        if(nums.length == 1) {return new int[]{-1};};
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        Deque<Integer> stack = new ArrayDeque<Integer>();
        int i = (nums.length -1) * 2;
        while(-1 < i && i < (nums.length -1) * 2 + 1) {
            int num = (i >= nums.length ? nums[i - nums.length] : nums[i]);
            while (!stack.isEmpty() && num >= stack.peek()) {
                stack.pop();
            }
            map.put(i >= nums.length ? i - nums.length : i, stack.isEmpty() ? -1 : stack.peek());
            stack.push(num);
            i--;
        }
        int[] res = new int[nums.length];
        for (int j = 0; j < nums.length; ++j) {
            res[j] = map.get(j);
        }
        return res;
    }