前言：由于在公司工作比较繁忙，导致之前刷的算法题忘记了许多，因此最近要大量回顾之前刷过的算法题，旨在有利于自己更好的复习，想跟着学习或复习的小伙伴儿们也可以参考一下🤞🤞
如果有什么需要改进的地方还请大佬斧正😁
小威在此先感谢诸佬了👏👏

🏠个人主页：小威要向诸佬学习呀
🧑个人简介：大家好，我是小威，一个想要与大家共同进步的男人😉😉
目前状况🎉：目前大二，在一家满意的公司实习👏👏

🎁如果大佬在准备面试，找工作，刷算法，可以使用我找实习前用的刷题神器哦刷题神器点这里哟
💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬😘

牛客部分使用反馈，个人感觉还不错，帮我找到了心仪的公司，希望各位伙伴儿们通过它也能提高不少🥂🥂🥂

以下正文开始

环形链表||

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1
输出：返回 null
解释：链表中没有环。

题解：
双指针环类问题中，大多数都可以用快慢指针的方法来解决，即定义两个指针，快指针一次走两步，慢指针一次走一步，如果链表中没有环，那么快慢指针无论什么时候都不会相遇，如果链表中有环，则快慢指针必定会在环内的某一节点相遇，因为快指针相对于慢指针多走一步，可以自己画图模拟一下便于理解~。

假设环形周长为D，slow从0移动到2长度为L，则fast移动的距离为2L，此时fast与slow间隔（D-L），假设此时在5位置相遇，那么slow移动了（D-L），而fast移动了2（D-L），所以2到5的距离为D-（D-L）为L，因此，从头结点和相遇的节点两边同时移动，相遇的位置即为入环的位置。

代码+详解：

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head==null){
            return null; //如果链表为空，则直接返回空
        }
        ListNode slow=head,fast=head; //定义快慢指针，都从头结点开始
        while(fast!=null){  //快指针移动的快，如果有环的话不会终止运行
            slow=slow.next;  //慢指针每次移动一步
            if(fast.next!=null){  //这里是为了防止空指针异常
                fast=fast.next.next; // 快指针每次移动两步
            }else{
                return null;  //没有环则返回null
            }
            if(fast==slow){
                ListNode fast1=head;  //指向头结点
                while(fast1!=slow){  //循环，直到临时变量与slow相遇即为入环的位置
                    fast1=fast1.next;
                    slow=slow.next;  //
                }
                return slow;  //返回结果slow的位置
            }
        }
        return null;  //如果没有找到该节点则返回null
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

测试用例的答案是一个 32-位 整数。

子数组 是数组的连续子序列。

示例 1:

输入: nums = [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: nums = [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

题解：题目要求乘积最大并且连续，所以一定要考虑到正负号，至少需要遍历一次。由于不知道下一位是整数还是负数，因此要使用动态规划的思想来解决，对每一步的值进行保存，接着判断下一个值，不停地更换值是核心。

代码+解释：

class Solution {
    public int maxProduct(int[] nums) {
        int max=Integer.MIN_VALUE,imax=1,imin=1; //先将结果max置为整型中的最小值，初始化临时的最大和最小值。
        for(int i=0;i<nums.length;i++){ //这里从起始位置进行遍历
            if(nums[i]<0){  //这里判断正负号，如果遇到负数的话最大值和最小值要交换。
                int tmp=imax;
                imax=imin;
                imin=tmp;
            }
            imax=Math.max(imax*nums[i],nums[i]); //比较临时最大值和当前值大小并赋值
            imin=Math.min(imin*nums[i],nums[i]); //比较临时最小值和当前值大小并赋值
            max=Math.max(max,imax);  //更新结果值
        }
        return max;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

文章到这里就结束了，以后还会继续更新刷过的算法题并继续刷题，想要学习的话可以和博主一块来复习哈~😉😉。
如果有什么疑问的地方请指出，诸佬们一起讨论🍻🍻

最后再次给大家安利一波牛客，牛客真的很不错的软件，点击刷题神器
注册牛客，快来和博主一起刷题吧嘿嘿嘿👏
同时祝伙伴儿找到理想的工作及猛猛地提升算法能力哦😏

再次感谢各位小伙伴儿们的支持🤞