LeetCode刷题第六周

听说开学又要延期了！

---

链表专题

简单

141. 环形链表

题目链接： 点击跳转至本题

题目大意：
给定一个链表，判断链表中是否有环。为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

解题思路：
方法1：二倍追击（推荐）
判断链表是否有环，可以设置快慢指针同时从链表首元节点开始移动，慢指针每次移动一步，快指针每次移动两步。只要两指针相遇，那就一定是一个环。

方法2：哈希表
用散列表HashSet记录走过的结点，如果出现重复则说明走回来了，成环。

//方法1：双指针追击
public class Solution {
    public boolean hasCycle(ListNode head) {
        //定义快慢指针
        ListNode slow = head;
        ListNode fast = head;
        while(slow != null && fast != null && fast.next !=null){
            //慢指针每次走一步
            slow = slow.next;
            //快指针每次走两步
            fast = fast.next.next;
            //相遇即是环
            if(slow == fast){
                return true;
            }
        }
        return false;
    }
}

//方法2：散列表
public class Solution {
    public boolean hasCycle(ListNode head) {
         Set<ListNode> node = new HashSet<>();
         while(head!=null){
            if(node.contains(head)){
                 return true;
             }else{
                 node.add(head);
             }
             head = head.next;
         }
         return false;
    }
}

160. 相交链表

题目链接： 点击跳转至本题

题目大意：
给定两个链表，要求返回两个链表相交的起始节点，若无相交节点则返回null。

解题思路：浪漫指针
在做141. 环形链表时，判断是否是环形链表的方法是双指针二倍追击，如果相遇即是环；本题判断相交链表仍然使用双指针追击，暂且叫他浪漫指针。两链表判相交，可以让链表分别走到尽头，然后分别走另一条链表走过的路线。此时若再相遇，即是相交。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //特判:是空链表时直接返回
        if(headA == null || headB == null){
            return null;
        }
        //定义两个链表的工作指针
        ListNode pA = headA,pB = headB;
        //走到尽头见不到你，于是走过你来时的路，等到相遇时才发现，你也走过我来时的路。
        while(pA != pB){
            pA = pA == null ? headB:pA.next;
            pB = pB == null ? headA:pB.next;
        }
        return pA;
    }
}

203. 移除链表元素

题目链接： 点击跳转至本题

题目大意：给定一个链表，要求删除链表中等于给定值 val 的所有节点。

解题思路：哨兵节点+快慢指针
删除链表元素中值等于val的节点，看起来似乎很简单，但当要删除的一个或多个节点位于链表的头部时，就会变得很复杂。为此可以采用快慢指针，pre1作为慢指针，pre2作为快指针，每次都让pre2和val进行判断，然后让pre1的下一个节点连接到pre2的下一个节点。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //设置哨兵节点
        ListNode preHead = new ListNode(0);
        preHead.next = head;
        //pre1，pre2为工作指针
        ListNode pre1 = preHead,pre2 = head;
        while(pre2 != null){
            if(pre2.val == val){
                pre1.next = pre2.next;
            }else{
                pre1 = pre2;
            }
            pre2 = pre2.next;
        }
        return preHead.next;
    }
}

206. 反转链表

题目链接： 点击跳转至本题

题目大意：反转一个链表

解题思路：双指针迭代
反转一个单链表需要借助一个pre节点、cur节点、tmp节点。其中pre节点始终指向新的链表的链表头，cur节点对当前链表做遍历，tmp节点对当前节点的下一个节点做保存。题目比较经典，建议数量掌握。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

234. 回文链表

题目链接： 点击跳转至本题

题目大意：判断一个链表是否为回文链表。

解题思路：双指针迭代反转链表+双指针二倍追击
考虑使用二倍追击得到链表中间节点（中间靠右的节点），此时将链表的后半段进行反转。然后比较给出的链表与反转得到的链表。

/**
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //特判:空链表或只有一个节点直接返回true
        if(head == null || head.next ==null){
            return true;
        }

        //end表示前后半段链表的头节点
        ListNode end = halfList(head);
        //L表示对链表后半段反转后的链表
        ListNode L = reverseList(end);
        
        //判断是否相等
        ListNode p1 = head;
        ListNode p2 = L;
        boolean result = true;
        while(result && p2 != null){
            if(p1.val != p2.val) {
                result = false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        //可以考虑将链表还原
        //end = reverseList(L);
        return result;
    }

    /**
        反转链表
        pre节点指向新链表的头
        cur为遍历节点
        tmp保存cur下一个节点的值
    **/
    private ListNode reverseList(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }

    /**
        二倍追击
        返回的slow代表后半段链表的起始节点
    **/
    private ListNode halfList(ListNode head){
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

237. 删除链表中的节点

题目链接： 点击跳转至本题

题目大意：写一个方法，删除当前节点。
注意：当前节点非末尾节点。

解题思路：与下一个节点交换
本题只是要求写一个方法删除当前节点，可以将下一个节点的值赋给当前节点，然后删除下一个节点。而在203. 移除链表元素中，是给出了链表的头节点和待删除节点的。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        //将后一个节点的val赋给node
        node.val = node.next.val;
        //删除node后面的节点
        node.next = node.next.next;
    }
}

中等

92. 反转链表 II

题目链接： 点击跳转至本题

题目大意：
反转从位置 m 到 n 的链表。
说明:1 ≤ m ≤ n ≤ 链表长度。要求使用一趟扫描完成反转

解题思路：哨兵节点+快慢指针
如下图，定义快慢指针p和q。首先，将p移动到m节点的前一个节点，q在m处，然后开始遍历n-m次，每次的操作过程可参照代码和图示理解。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        //设置哨兵节点
        ListNode preHead = new ListNode(0);
        preHead.next = head;
        //p作为慢指针,q作为快指针
        ListNode p = preHead;
        ListNode q = preHead.next;
        //将p移动到m节点的前一个节点
        int num = 0;
        while(num < m - 1){
            p = p.next;
            q = q.next;
            num++;
        }
        //将q从m处遍历到n处
        for(int i=0;i<n-m;i++){
            //定义temp节点保存q.next节点
            ListNode temp = q.next;
            //删除q.next节点
            q.next = q.next.next;
            //temp节点连接上p.next节点
            temp.next = p.next;
            //p.next连接上temp节点
            p.next = temp;
        }
        return preHead.next;
    }
}

142. 环形链表 II

题目链接： 点击跳转至本题

题目大意：
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

解题思路：HashSet
本题可以使用双指针进行快慢追击，但是过于复杂，这里使用不可重复的集合HashSet来进行比较判断，当下一个将要添加到set的节点已经存在再set中的时候，返回下一个节点。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        //HashSet是不可以重复的集合
        Set<ListNode> set = new HashSet<ListNode>();

        ListNode node = head;
        while (node != null) {
            //如果出现重复，就返回第二个节点
            if (set.contains(node)) {
                return node;
            }
            //依次将每一个节点加入set集合
            set.add(node);
            node = node.next;
        }
        return null;
    }
}

148. 排序链表

题目链接： 点击跳转至本题

题目大意：
在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

解题思路：归并排序
链表使用归并排序，主要有分解和合并两个环节：

分解操作：

• 找到链表中点并断开（使用块面快慢指针法，奇数个节点时slow是中点，偶数个节点时slow是中点左边的节点）。
• 找到中点slow后，将链表切断（slow.next=null;）。
• 递归分解时，输入当前链表的左端点head和中心节点slow的下一个节点head2。
• 递归终止条件是head.next==null。

合并操作：

• 将两个有序链表合并，转化为一个有序链表。
• 设置left，right分别指向两链表头部，比较指针处节点值大小，由小到大加入哨兵节点中的工作节点中。
• 返回哨兵节点的下一个节点。

注意：使用归并排序时，链表可以通过修改引用来更改节点顺序，所以无需像数组一样开辟额外空间。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    /*
        head     slow  | head2     fast   
    */
    public ListNode sortList(ListNode head) {
        //特判:只有0个或1个节点的链表
        if(head == null ||head.next == null){
            return head;
        }
        //二倍追击，最终使slow落在中间，fast到达结尾
        ListNode slow = head,fast = head.next;
        while(fast !=null && fast.next!=null){
            slow = slow.next;
            fast = fast.next.next;
        }
        //定义head2表示右边的有序数据
        ListNode head2 = slow.next;
        //左边有序数据从slow.next断开
        slow.next = null;
        //下两行是递归分解
        ListNode left = sortList(head);
        ListNode right = sortList(head2);
        //创建哨兵节点，方便存储结果
        ListNode preHead = new ListNode(0);
        ListNode pre = preHead;
        /**
            下面是合并操作
        **/
        //1.先把左右两边(有序)的数据按照规则链接到pre后
        while(left != null && right !=null){
            if(left.val < right.val){
                pre.next = left;
                left = left.next;
            }else{
                pre.next = right;
                right = right.next;
            }
            pre = pre.next;
        }
        // 2.把有剩余数据的一边的数据依次链接到pre后
        pre.next = left !=null ?left:right;
        return preHead.next;
    }
}

328. 奇偶链表

题目链接： 点击跳转至本题

题目大意：
给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

解题思路：首尾指针
分别定义奇偶链表的头尾节点，可以将head直接作为奇链表的头，再额外定义其他三个指针。一次遍历，将奇节点都放在奇链表中，偶节点都放在偶链表中，最后将偶链表链接在奇链表尾部。

/**
 * 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 oddEvenList(ListNode head) {
        if(null == head){
            return null;
        }
        //head表示奇链表的头,odd表示奇链表工作指针;evenHead表示偶链表头,even表示偶链表工作指针
        ListNode odd = head;
        ListNode evenHead = head.next;
        ListNode even = evenHead;
        while(even != null && even.next != null){
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}