不勤奋

算法系统练习

学习目标：

一周算法训练（10.17-10.22）
一周算法训练（10.23-10.29）{未完成，一周不知道在忙啥}
一周算法训练（10.30-11.5）

学习内容：

每天至少刷一道题

学习时间：

Everyday

学习产出：

一周至少五篇算法笔记

力扣： 27. 移除元素

题目：
给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

题目分析：
这是一个时间复杂度为O(n)的双指针算法
定义了两个指针：
1.快指针：用于扫描初始数组元素
2.慢指针：为了更新数组（也可以称为新数组赋值）
首先用快指针遍历数组，当fast指针指向的数组元素不是目标元素时，就让low指针为新数组赋值为fast指针指向的元素。

 public int removeElement(int[] nums, int val) {
        int slow=0;
        for(int fast=0;fast<nums.length;fast++){
            if(nums[fast]!=val){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }

力扣：977. 有序数组的平方

题目：
给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
题目分析：

Reading problem ：得知会给你一个数组并且是一个递增数组（包含正数负数的递增数组），要求返回一个数组每个元素平方后的递增数组
To begin with：我们会第一时间想到暴力方法：先将数组每个元素平方，然后再来个快排。其时间复杂度取决于排序方法的时间复杂度
What’s more : 我们将使用一个时间复杂度仅为O(n)的方法，那就是双指针法
1.首先创建一个新数组和传入的数组长度一样，目的是将原数组由大到小处理
2.定义k用于指向新数组的尾部，由大到小处理的缘故
3.for循环定义两个指针，用于分别指向原数组的头部和尾部，循环条件是这两个指针不能超过对方
4.执行条件为当头指针指向元素的平方大于尾指针指向元素的平方时将较大的那个数的平方存到k指针指向的位置，头指针++
5.另一个条件即为上面条件相反的情况，尾指针–
上面两个条件任意一个条件都可包含相等的情况：因为当指向的那两个元素只会出现先存入一个的情况，未存入的元素会进行下一次循环（这边是需要理解一下，其实糊里糊涂写完发现还是能过的不过要搞清楚才好）

class Solution {
    public int[] sortedSquares(int[] nums) {
        int [] result=new int [nums.length];
        //指向新数组的最后一个元素
        int k=nums.length-1;
        for(int i=0,j=nums.length-1;i<=j;){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[k--]=nums[i]*nums[i];
                i++;
            }else{
                result[k--]=nums[j]*nums[j];
                j--;
            }
        }
        return result;
    }
}

LCR 008. 长度最小的子数组

题目：
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
题目分析：

Reading problem :给定一个数组和整数，要求在数组中找到连续的元素和大于等于这个给定的整数，符合条件则返回最短长度，不符合条件则返回0
首先想到的思路就是双层for循环，接着找两个存储元素个数的变量，里层for循环获取元素和，外层for循环控制每层for循环的元素减少。不过要及时控制里层for循环的结束。
这里我们用到的是双指针法-滑动窗口。
要明白i 和 j 的两个变量的含义；j具体代表的是初始位置呢还是结束位置呢？
1.假设j代表的是初始位置那么和暴力解法有啥区别呢？
因此i代表滑动起始位置，j代表结束位置：
首先遍历元素，并求和，当sum>=给定的整数时进行滑动窗口或者说剪枝，从头部开始滑动，（可能有人问为什么不从尾部滑动，因为尾部是我们刚好满足sum>=target的条件，滑动尾部不就马上不满足条件了）
滑动的思路大概就是：先获取你目前窗口的长度，并且与你之前的窗口做比较，紧接着就是滑动：sum-窗口第一个元素，窗口索引++
我们需要考虑滑动窗口的执行是if 还是 while 呢？
想当然那就是while，因为你不确定你执行一次剪枝后是否为最短长度，只有执行到不满足条件结束才能确保不满足条件的前一次是最短的。
有些人看到代码还是有些不明白。可能会考虑到这个j不是从0遍历到数组最后一个元素吗？那为什么会有j会有固定结束位置呢？其实固定结束位置（窗口最短长度）是我们用变量保存起来的，当你在前面数组元素中遍历到最短窗口但是你不清楚后门数组是否有更短的窗口，所以我们提前将我们目前已知最短长度保存起来了，到后面我们获取到后半部分数组中最短窗口长度后进行一个比较。因此这个j的位置是与你所参考的位置不同导致j的含义不同的。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //i是滑动窗口的起始位置
        int i=0;
        //result初始化值为自定义的最大值
        int result=Integer.MAX_VALUE;
        int sum=0;
        int sub=0;
        for(int j=0;j<nums.length;j++){
            sum+=nums[j];
            while(sum>=target){
                sub=j-i+1;
                //与之前的最短窗口进行比较
                result=Math.min(result,sub);
                //剪枝或者滑动
                sum=sum-nums[i];
                //滑动
                i++;
            }
        }
     
        return result==Integer.MAX_VALUE ? 0:result;
    }
}

LCR203. 移除链表元素

**题目：
**给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。
示例 1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：
输入：head = [], val = 1
输出：[]
示例 3：
输入：head = [7,7,7,7], val = 7
输出：[]
题目分析：

就是一道最基本的单链表元素删除，一定要看清楚题目是单链表，这三个测试案例基本上涵盖了所有的特殊情况
首先看第二个测试案例，当我们的头节点为空时直接返回头节点就行；
看第三个测试案例，当头节点和其他结点的值都为目标值，这时我们需要额外注意的特殊情况，我们的操作条件就是当头节点等于目标值并且当头节点的下一个结点不为空时，我们直接将下一个结点覆盖为头节点即可，返回执行直至不满足条件，那就需要用到while。
第一个测试案例就是我们最基本的删除元素情况。这个情况时我们需要用到一个临时结点来遍历整个链表，如果不使用临时结点，用头节点遍历会出现啥情况呢？当我们有三个结点时，第三个结点为要删除的目标结点，那该如何遍历到第三个结点呢？用head=head.next。那就会导致头部结点被覆盖，最终会导致整条链表混乱。所以单链表遍历必须用到临时结点。
有些人不懂我们创建一个临时变量存储初始值为头节点，那这个临时结点为什么还有.next？因为头节点封装时就是有两个属性一个为int值另一个为next属性。当将临时结点存储头节点时，同时具备了头节点的所有能力和所有关系。
删除头节点的操作在上面我们已经进行了，接下来操作就是删除除头节点的操作。因此第三个测试用例，我们该如何遍历删除呢，首先创建临时结点保存头节点，我们执行的条件是啥呢？必然有一个当前节点不为空，另一个可想而知就是当前节点的下一个结点不为空（必须要有一个条件，当我们用到下一个结点时并且下一个结点不为空，那么就会出现空指针异常），在这当前节点就是临时结点。当我们遍历到当前结点的下一个结点为目标结点时，直接将当前结点的下一个结点指向当前结点的下下个结点。如果当前结点的下一个结点不是目标结点，要向下继续遍历那么就是当前结点指向当前节点的下一个结点。

/**
 * 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 removeElements(ListNode head, int val) {
    while(head!=null&&head.val==val){
        head=head.next;
    }
    if(head==null){
        return head;
    }
    ListNode cur=head;
    //利用临时结点删除，因为是单链表
    while(cur.next != null){
        if(cur.next.val==val){
            cur.next=cur.next.next;
        }else{
             cur=cur.next;
        }
        }
    return head;
    }
}

LCR82. 删除排序链表中的重复元素 II

题目：
给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。
示例 1：
输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]
示例 2：
输入：head = [1,1,1,2,3]
输出：[2,3]
初做反思：

刚拿到题目时，我认为需要几种特殊情况，当头节点与后续节点相同时，当后续节点有相同值。但是没想到合适的变量来处理这些关系，怎么删除也删除不干净。
我发现行不通，接着转换思想，那我们在数组中如何删掉重复元素，只留下不同数字呢？我就打开Idea操作？发现需要用到一个新的容器来存放不同数字。那该如何对比相不相同的数字呢？
获取第一个元素，并保留第一个元素的值，接着向下遍历，遇到不同则保存，相同则跳过。
但是我无法将数组的思想应用到链表中，原因归咎于本身对链表的掌握程度不够

题目分析：

我们需要一个虚拟节点放在头节点的前面，因为我们无法像数组那么直接操作第一个元素。接着创建辅助结点用来遍历虚拟结点。
我们从指针 cur 指向链表的虚拟节点，随后开始对链表进行遍历。当cur.next和cur.next.next的值相等时，我们将cur.next及以后所有的相同元素的节点全部删掉。具体如何删掉呢，我们需要将判断相等后的值存储下来，然后向后遍历，当相等时将自身指向下一个节点，直至cur.next节点不等于存储下来的值。
当两个节点元素不相等时，我们直接向下遍历。
最后返回虚拟节点的下一个节点。

时间复杂度为O（n），空间复杂度为O（1）。即使两个嵌套while但是每次循环要么删除一个节点，要么向右移动，所以循环次数为O(n)

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head==null){
            return head;
        }
       ListNode dunny=new ListNode(0,head);
       ListNode cur=dunny;
       //第一个结点和下一个结点
       while(cur.next!=null&&cur.next.next!=null){
            if(cur.next.val==cur.next.next.val){
                int x=cur.next.val;
                while(cur.next!=null && cur.next.val==x){
                    cur.next=cur.next.next;
                }
            }else{
                cur=cur.next;
            }
         }
        return dunny.next;
    }
}

LCR707. 设计链表

**题目：**你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将不会插入到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

思路：

本题目我是用了单链表结构，运用前驱节点的思想
首先创建节点类，补充成员变量和1构造方法。
初始化链表
int get(int index) 方法。首先处理特殊情况当传入的索引不合法则直接返回。接着就用到了前驱节点：ListNode pred=head; 这并不是将head的值赋值给前驱节点，而是将前驱节点指向head（目前我是这么理解点，其实还是有点不懂）。接着往下遍历直至遍历到目标索引的前驱节点。
void addAtIndex(int index, int val)。首先判断特殊情况和题目要求的特殊情况。还是利用前驱节点。遍历到目标位置是需要执行的操作为：
toAdd.next = pred.next;
pred.next = toAdd;
void deleteAtIndex。和前几个思想基本一致，前驱节点的思想。

class ListNode{
        int val;
        ListNode next;
        ListNode(){}
        ListNode(int val){
            this.val=val;
        }
    }
class MyLinkedList {
    int size;
    ListNode head;
   
    public MyLinkedList() {
        size=0;
        head=new ListNode(0);
    }
    
    public int get(int index) {
        //索引下标非法 返回-1;
        if(index < 0 || index >=size){
            return -1;
        }
        //
        ListNode pred=head;
        for(int i=0;i<=index;i++){
            pred=pred.next;
        }
        return pred.val;
    
    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);
         
    }
    
    public void addAtTail(int val) {
         addAtIndex(size, val);
       
    }
    
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        ListNode toAdd = new ListNode(val);
        toAdd.next = pred.next;
        pred.next = toAdd;
    }
    
    public void deleteAtIndex(int index) {
     if (index < 0 || index >= size) {
            return;
        }
        size--;
       if (index == 0) {
            head = head.next;
	    return;
       }
       ListNode pred=head;
       for(int i=0;i<index;i++){
           pred=pred.next;
       }
       pred.next=pred.next.next;
       
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

LCR 024. 反转链表

题目：
给定单链表的头节点 head ，请反转链表，并返回反转后的链表的头节点。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例2：
输入：head = []
输出：[]
思路：

双指针的思想，前面我们对数组的操作很多都是双指针操作，那么本题难度其实不是思想，而是当把对数组的操作改为对链表的操作
这里其实有很多细节需要我们注意。首先是当我们什么时候结束遍历 1.cur.next!=null（这样会导致空指针异常，其实很好理解。当我们head头节点为空时，那么引用了head.next那么必然会导致空指针异常。）2.cur！=null(只能用这个条件了)
另外个需要注意的是：在第一次操作后我们该如何为cur 和 pre 赋值呢？这里我们用到了temp遍历存储cur.next的值。（为什么要先将值存起来呢？？）因为当我们将cur.next指向pre时这个节点的原本指向下一个节点的这个线就会断了，导致失去联系，所以我们需要先将后一个节点存储来。
下一步就是将pre后移，在将temp赋值给cur。这个操作顺序是不可以改变的。要不然会导致cur数据丢失。
最后返回pre节点。为什么要返回pre看图就可明白了。

/**
 * 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 reverseList(ListNode head) {
    ListNode cur=head;
    ListNode pre=null;
    ListNode temp=null;
    while(cur!=null){
        temp=cur.next;
        cur.next=pre;
        pre=cur;
        cur=temp;
    }
    return pre;
    }
    
    //递归写法
     public static ListNode recursion(ListNode cur,ListNode pre ,ListNode temp){
        if(cur==null){
            return pre;
        }
        temp=cur.next;
        cur.next=pre;
        pre=cur;
        cur=temp;
        return recursion(cur,pre,temp);
    }
}

24. 两两交换链表中的节点

题目：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]
示例 2：
输入：head = []
输出：[]
示例 3：
输入：head = [1]
输出：[1]
题目分析：
这里我们用到了虚拟头节点的方法：

这里我们先定义了一个虚拟头节点，用来指向head节点。
我们只能操作两个节点。当为链表节点个数为奇数时，最后一个节点我们是不需要操作的。只有个数为偶数个时才会全部操作
当我们要修改第一个节点的指向（不包括虚拟节点）一定要直到前一个结点的指向，因此我们需要用到虚拟头节点.
我们只有先将虚拟结点指向第二个节点（除虚拟节点外的）,这里需要提前存储一下第一个节点和第三个节点。只有这样才能保持连接。因为我们保存了第一个节点我们就可以直接将第二个节点指向第一个节点，
最后需要更新cur的值，为被操作节点的前一个节点。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode dummy= new ListNode(-1);
        dummy.next=head;
        ListNode cur=dummy;

        ListNode temp1=null;
        ListNode temp2=null;
        while(cur.next!=null&&cur.next.next!=null){
            temp1=cur.next;
            temp2=cur.next.next.next;
            cur.next=cur.next.next;
            cur.next.next=temp1;
            temp1.next=temp2;
            cur=temp1;
        }
        return dummy.next;
    }
}

19. 删除链表的倒数第 N 个结点

题目：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：
输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
题目分析：

首先我拿到题目的思路是：自定义一个方法获取链表的总长度，然后总长度减去n，得到的不就是我们正方向的顺序吗？但是用这个思路你会陷入很多坑，分不清第一步是0还是1，让人头大，还会时不时的空指针。
接下来就是另一种思路。我们打个比方在一列孩子中找出倒数第n个孩子。并且我们我们无法得知这一列孩子的总数。我们该怎么办呢？（每个孩子之间间隔一米）
我们可以向别的班借两个孩子，先让第一个孩子跑n米（停下），接着让第二个孩子和第一个孩子同时以同样的速度起跑，当第一个孩子到达终点时停止运动。这时第二个孩子所在的位置就是我们要找的倒数第n个孩子
那么我们在链表中该如何操作呢？在之前我们知道删除节点需要知道要删除节点的前一个节点，让前一个节点指向要删除节点的下一个节点。删除工作及完成
用到了虚拟头节点的思想，我们要知道删除节点的前一个结点，即我们需要快指针先走n+1步
那当什么时候我们停止快指针的运动，然后和慢指针一起运动呢？那就是当n–>0并且快指针并未到达末尾。（这里我们需要考虑为什么不是n–>=0?其实当它等于0时还是满足条件还会接着往下走一步，这一步就会影响慢指针的位置，）
如果理解不了可以画图看看

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode fast=dummy;
        ListNode low=dummy;
        n++;//让fast指针多走一步，提前进入空节点（即末尾的后面的空节点
        while(n-->0&&fast!=null){
            fast=fast.next;
        }
        while(fast!=null){
            fast=fast.next;
            low=low.next;
        }
        low.next=low.next.next;
        return dummy.next;
    }
}

LCR 022. 环形链表 II

题目：
给定一个链表，返回链表开始入环的第一个节点。从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。

为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意，pos 仅仅是用于标识环的情况，并不会作为参数传递到函数中。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。