为了面试！为了“躺钱”！努力刷题！
一般是发中等难度以上的题目。如果简单难度的题有巧妙的解法也会发一下。（使用的语言是java）

leetcode19. 删除链表的倒数第N个节点 难度：中等
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例： 给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明： 给定的 n 保证是有效的。
进阶： 你能尝试使用一趟扫描实现吗？

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //基本思路：我们只需要记录对于当前节点来说的前面第n+1个节点的引用即可
        //当遍历到最后一个节点时，此时当前节点（即最后一个节点）的前面第n+1个节点的引用自然就是整个链表的倒数第n+1个节点

        //特殊情况判断
        if(head == null) return head;
        if(head.next == null) {
            if(n == 0) return head;
            else return null;
        }
        //倒数第 n + 1个的引用
        ListNode lastN = head;
        //遍历：当前的节点的引用
        ListNode now = head;
        //遍历：当前节点的索引
        int index = 0;

        while(now != null) {
            //当索引大于n时，才将倒数第n + 1个节点的引用进行更新
            if(index > n) lastN = lastN.next;
            //索引和当前节点引用更新
            index++;
            now = now.next;
        }
        //如果去掉第一个节点则直接返回第二个节点
        if(index == n) return head.next;
        //把第n+1个节点的下一个引用变为n-1个节点
        lastN.next = lastN.next.next;

        return head;
    }
}

leetcode.134-每日一题-加油站
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
说明:
如果题目有解，该答案即为唯一答案。
输入数组均为非空数组，且长度相同。
输入数组中的元素均为非负数。

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        /*基本思路：从第一个个加油站作为起点，如果到第n个加油站时无法前进
        则说明前面n-1个加油站都不能作为起点，直接跳到第n个加油站作为起点*/

        //当前的汽油量
        int have = 0;
        //当前的起点站
        int now = 0;
        //只有一个加油站时直接返回
        if(gas.length == 1) {
            if(gas[0] >= cost[0]) return 0;
            else return -1;
        }

        for(int i = 0; i < gas.length; i++) {
            //标记起点的索引
            now = i;
            //以now为起点开始出发
            for(int k = 0; k <= gas.length; k++) {
                have +=  gas[now];
                //汽油足够继续前进的情况
                if(have >= cost[now]) {
                    have -= cost[now];
                    //如果已经环绕一圈就直接返回答案
                    if(k == gas.length) return now;
                    //前进
                    now++;
                    //为了绕圈，需要进行取余
                    now %= gas.length;
                }
                //汽油不够，更新起点为：当前起点无法到达的那个加油站
                else {
                    //重置汽油
                    have = 0;
                    //如果要更新的加油站在起点身后，那就不更新继续往前
                    i = Math.max(now, i);
                    break;
                }
            }
        }
        //所有情况均不满足则返回-1
        return -1;
    }
}

leetcode.283-移动零-每日一题-难度：简单
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。

class Solution {
    public void moveZeroes(int[] nums) {
        /*基本思路：暴力法+小优化
        首先找到第一个零元素 然后以这个零元素为起点往后找第一个非零元素互换位置 
        找到的同时记录该非零元素位置，作为寻找下一个非零元素的起点*/

        //下一个非零元素的起点
        int index = 0;
        for(int i = 0; i < nums.length; i++) {
            //寻找下一个零元素
            if(nums[i] == 0) {
                //以零元素为起点往后寻找第一个非零元素
                for(int j = index; j < nums.length; j++) {
                    //找到了就互换并更新下一个非零元素寻找的起点，然后退出循环
                    if(nums[j] != 0 && j > i) {
                        index = j;
                        nums[i] = nums[j];
                        nums[j] = 0;
                        break;
                    }
                }
            }
        }
    }
}

leetcode.62:不同路径-难度：中等
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？

例如，上图是一个7 x 3 的网格。有多少可能的路径？
示例 1:
输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。

class Solution {
    public int uniquePaths(int m, int n) {
        /* 基本思路：动态规划：当前点的可能数为左边+上边的可能数
        最左边、最上边的可能数都是1 
        */

        int[][] record = new int[m][n];
        //最左边都是1
        for(int i = 0; i < m; i++) {
            record[i][0] = 1;
        }
        //最上边都是1
        for(int i = 0; i < n; i++) {
            record[0][i] = 1;
        }
        //当前等于左边+上边
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                record[i][j] = record[i-1][j] + record[i][j - 1];
            }
        }
        return record[m - 1][n - 1];
    }
}

leetcode.75:颜色分类-hot100题
给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。
进阶：
你可以不使用代码库中的排序函数来解决这道题吗？
你能想出一个仅使用常数空间的一趟扫描算法吗？
示例 1：
输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

class Solution {
    public void sortColors(int[] nums) {
        //基本思路：扫描每个颜色的数量，根据数量重建数组，则时间复杂度为O(n),空间复杂度为O(1)
        int red = 0;
        int blue =0;
        int white = 0;
        //扫描数组中每个颜色的数量
        for(int i = 0; i < nums.length; i++) {
            if(nums[i] == 0) red++;
            else if(nums[i] == 1) white++;
            else if(nums[i] == 2) blue++;
        }
        //重建数组
        for(int i = 0; i < red; i++) {
            nums[i] = 0;
        }
        for(int i = red; i < red + white; i++) {
            nums[i] = 1;
        }
        for(int i = red + white; i < nums.length; i++) {
            nums[i] = 2;
        }
    }
}

leetcode.11:盛最多水的容器-hot100
给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器
示例 1：
输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

class Solution {
    public int maxArea(int[] height) {
        /*基本思路：把左右指针分别指向最左和最右，此时底部长度最大。每左移或者右移一步，底部长度都减少一
        因此要移动 高比较小 的那一边
        */

        int left = 0;
        int right = height.length - 1;
        int max = 0;

        while(left < right) {
            //如果左边大就移动右边
            if(height[left] >= height[right]) {
                max = Math.max(max, height[right] * (right - left));
                right--;
            }
            //如果左边小就移动左边
            else {
                max = Math.max(max, height[left] * (right - left));
                left++;
            }
        }
        return max;
    }
}

好像没用很多变量，为什么内存消耗这么高呢？疑惑

leetcode.21:合并两个有序链表-hot100
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        /* 基本思路：把两个链表看成两条队伍，最前面的一定是当前队伍最小的。
        只要每次取出两个队头比较小的那个值，就可以保证合并以后的顺序*/

        //使用一个空节点作为新链表的头节点
        ListNode resultHead = new ListNode();
        //新链表的尾节点
        ListNode now = resultHead;

        while(l1 != null || l2 != null) {
            //当l1 或者 l2 其中有一个为空时，则取另一边
            if(l1 == null) {
                now.next = l2;
                l2 = l2.next;
                now = now.next;
                continue;              
            }
            if(l2 == null) {
                now.next = l1;
                l1 = l1.next;
                now = now.next; 
                continue;       
            }
            //取两个队首较小的一个
            if(l1.val < l2.val) {
                now.next = l1;
                l1 = l1.next;
                now = now.next;   
                continue;       
            }
            else {
                now.next = l2;
                l2 = l2.next;
                now = now.next;   
                continue;   
            }  
        }
        //返回首节点
        return resultHead.next;
    }
}

leetcode452:用最少数量的箭引爆气球-每日一题
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。
一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。 弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。
给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。
示例 1：
输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球
提示：
0 <= points.length <= 104
points[i].length == 2
-231 <= xstart < xend <= 231 - 1

class Solution {
    public int findMinArrowShots(int[][] points) {
        /*基本思路：大家都在用的贪心法：将所有气球的右端点进行排序，每次都选取右端点最小的区间，并且把所有
        左端点在这个右端点偏左的区间都去掉，然后再选择右端点最小的区间，重复此过程*/

        //特殊情况直接返回
        if(points.length == 0) return 0;
        if(points.length == 1) return 1;
        //最少用一支箭
        int result = 1;

        //右端点排序
        Arrays.sort(points, (a, b) -> (Integer.compare(a[1], b[1])));

        int right = points[0][1];
        for(int i = 1; i < points.length; i++) {
            //如果有左端点在当前最小右端点右边的，则选择此点继续
            if(right < points[i][0]) {
                result++;
                right = points[i][1];
            }
        }     
        return result;
    }
}

leetcode.135:分发糖果
老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。
你需要按照以下要求，帮助老师给这些孩子分发糖果：
每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？
示例 1:
输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果
示例 2:
输入: [1,2,2]
输出: 4
解释: 你可以分别给这三个孩子分发 1、2、1 颗糖果。
第三个孩子只得到 1 颗糖果，这已满足上述两个条件。

class Solution {
    public int candy(int[] ratings) {
        /*基本思路：把情况分为上坡和下坡，上坡的时候要么是左边的个数加1，要么就是1
        从左往右遍历就是计算上坡的情况
        从右往左为计算下坡情况，下坡需要和上坡比较，取其中更大者
        */

        int[] result = new int[ratings.length];
        int sum = 0;
        Arrays.fill(result, 1);
        //上坡
        for(int i = 1; i <= ratings.length - 1; i++) {
            if(ratings[i] > ratings[i - 1]) {
                result[i] = result[i - 1] + 1;
            }
        }
        //下坡
        for(int i = ratings.length - 2; i >= 0; i--) {
            if(ratings[i] > ratings[i + 1]) {
                result[i] = Math.max(result[i + 1] + 1, result[i]);
            }
        }
        //求和
        for(int i = 0; i < ratings.length; i++) sum += result[i];
        return sum;
    }
}