LeetCode刷题 --- 链表

定义一个node节点

class ListNode {
    int val;

    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

206 反转链表

题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

解题：

1、如果head为空或者只有一个节点，那么直接返回结果即可

2、否则，定义一个新链表，遍历旧链表，将每个节点插入到新链表的头部即可。

    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode res = new ListNode(head.val);

        while (head.next != null) {
            ListNode next = head.next;
            head = next;

            res = new ListNode(next.val, res);

        }
        return res;
    }

203 根据值来删除节点

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

定义一个头节点，和两个指针， p和q，如图，循环该链表：

1、如果q指针的值不等于目标值，则分别向后移动一位

2、如果q指针的值等于目标值，则p不懂，q后移，但是p仍指向q

    public List1Node removeElements(List1Node head, int val) {
        // 定义哨兵和双指针
        List1Node myHead = new List1Node(-1, head);
        List1Node p = myHead;
        List1Node q = p.next;
        while (q!=null) {
            if (q.val == val) {
                // 右指针等于目标值，q右移,p不变，但是p还指向q
                q = q.next;
                p.next = q;
            } else {
                // 两个指针均向后移动一位
                p = p.next;
                q = q.next;
            }
        }
        return myHead.next;
    }

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

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

解题1：

1、先获取链表的长度

2、找到倒数第N个节点的前一个节点，指向下一个节点即可

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int length = length(head);

        ListNode dummy = new ListNode(0,head);
        ListNode cur = dummy;
        for (int i = 1; i < length -n +1; i++) {
            cur = cur.next;
        }
        cur.next = cur.next ==null ? null : cur.next.next;
        return dummy.next;
    }
    
    public int length(ListNode head) {
        if (head == null) {
            return 0;
        }
        ListNode p = head;
        int count = 1;
        while (p.next != null) {
            p = p.next;
            count++;
        }
        return count;
    }
}

解题2

定义两个指针节点p和q，分别指向头节点，先让q节点向后移动n步，然后，在让p和q同时后移，当q指向空的时候，p恰好是倒数第n个节点的前一个节点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0, head);
        ListNode p1 = dummy;
        ListNode p2 = dummy;

        for (int i = 0; i < n + 1; i++) {
            p2 = p2.next;
        }

        while (p2 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }

        p1.next = p1.next.next;
        return dummy.next;
    }
}

83、有序链表去重（留下一个）

给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表

解题1：

去重，可以使用Map或者set ，遍历链表，如果节点的值已经在集合中存在，那么这个节点就是重复节点，可以删除，如果不存在，则将值存入集合，继续遍历。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head==null){
            return head;
        }
        Set<Integer> set = new HashSet<>();
        ListNode node = head;
        set.add(node.val);
        while (node.next!=null) {
            ListNode next = node.next;
            if (set.contains(next.val)){
                node.next = next.next;
            }else {
                node = next;
                set.add(next.val);
            }
        }
        return head;
    }
}

解题2：

定义哨兵节点，和两个指针节点p/q，比较p/q的值是否相等，如果相等，q后移，p还是指向q，如果不相等，同时后移。

    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(-101, head);
        ListNode p = dummy;
        ListNode q = dummy.next;

        while (q != null) {
            if (q.val == p.val) {
                q = q.next;
                p.next = q;
            } else {
                q = q.next;
                p = p.next;
            }
        }
        return dummy.next;
    }

82. 删除排序链表中的重复元素（重复的一个不留）

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

解题：

参考上一题，定义哨兵节点，以及三个指针节点，仍然按照p和q比较，遍历，多定义的r节点，是p节点的上一个节点，pq相同的时候，q不断后移，一直移到为null或者值不同，然后将r的下一个节点指向q

    public ListNode deleteDuplicates(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(-200, head);
        ListNode r = dummy;
        ListNode p;
        ListNode q;

        while ((p = r.next) != null && (q = p.next) != null) {
            if (p.val == q.val) {
                while (q != null && q.val == p.val) {
                    q = q.next;
                }
                r.next=q;
            } else {
                r = r.next;
            }
        }
        return dummy.next;
    }

21 合并有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

解题：

定义一个新的头节点，遍历两个链表，哪个值小，就放在新建的头节点后面。如果有一个链表为null，那就把另外一个链表的值全放在新建链表的后面。

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        // 头节点，及指针节点
        ListNode head = new ListNode();
        ListNode node = head;

        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                node.next = list1;
                list1 = list1.next;
            } else {
                node.next = list2;
                list2 = list2.next;
            }
            node = node.next;
        }
        if (list1 != null) {
            node.next = list1;
        }
        if (list2 != null) {
            node.next = list2;
        }
        return head.next;
    }

23、和并多个升序链表

题解：参考21题，遍历链表，两两合并

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode node = null;
        for (int i = 0; i < lists.length; i++) {
            node = mergeTwoLists(lists[i], node);
        }
        return node;
    }
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        // 头节点，及指针节点
        ListNode head = new ListNode();
        ListNode node = head;

        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                node.next = list1;
                list1 = list1.next;
            } else {
                node.next = list2;
                list2 = list2.next;
            }
            node = node.next;
        }
        if (list1 != null) {
            node.next = list1;
        }
        if (list2 != null) {
            node.next = list2;
        }
        return head.next;
    }
}

876. 链表的中间结点

给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

题解：

快慢指针法，定义两个指针，初始分别指向头节点，p每次前进一步，q每次前进两步，当q前进时为null了，此时p指向的就是题目要求的中间节点。

    public ListNode middleNode(ListNode head) {
        ListNode p1 = head;
        ListNode p2 = head;

        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next.next;
        }
        return p1;
    }

243 回文链表

判断一个链表是不是回文链表，就是正读反读是一样的。

题解：

将给定的链表反转，然后将新链表和老链表逐个比较，一致则为true，否则为false。

    public boolean isPalindrome(ListNode head) {
        ListNode reverse = reverse(head);
        while (head != null) {
            if (head.val != reverse.val) {
                return false;
            }
            head = head.next;
            reverse = reverse.next;
        }
        return true;
    }

    public ListNode reverse(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

        ListNode res = new ListNode(head.val);

        while (head.next != null) {
            ListNode next = head.next;
            head = next;
            res = new ListNode(next.val, res);

        }
        return res;
    }

链表判环算法：

用快慢指针的方法（龟兔赛跑算法）：

阶段1
龟一次走一步，兔子一次走两步
兔子能走到终点，那么就不存在环
兔子能追上龟（再次相遇），说明存在环。
阶段2
再次相遇时，兔子留在原地不动，龟退回到起点
兔子和龟都每次走一步
再次相遇的时候，相遇点就是环的入口。

解释一下阶段2：

假设起点到环入口是a步，环一圈是b步
从起点开始，走a+b*n都可以到环的入口
第一次相遇：
兔走了a + m*b +k 步，k是距离环入口的距离
龟走了a + n*b +k 步，k是距离环入口的距离, m>n
兔子走的路程是龟的两倍，所以龟 = 兔 - 龟 = x*n 圈，龟走的是圈的整数倍
因为走a+b*n都可以到环的入口，因此，从相遇点开始，在走a步，就可以找到环的入口。
这个还有一个小bug，就是如果a=0，那么起点就是环入口。

141、判断是否是环形链表

根据上述判环算法，可以直接写出代码

    public boolean hasCycle(ListNode head) {
        ListNode p = head;
        ListNode q = head;

        while (q != null && q.next != null) {
            p = p.next;
            q = q.next.next;
            if (q == p) {
                return true;
            }
        }
        return false;
    }

142 找到环形链表的入口

根据上述算法，可以直接在141的基础上改写代码

    public ListNode detectCycle(ListNode head) {
        ListNode p = head;
        ListNode q = head;

        while (q != null && q.next != null) {
            p = p.next;
            q = q.next.next;
            if (q == p) {
                // 判断里面改写代码，将p重新指向头节点，然后两个节点每次分别走一步
                p = head;
                while (true) {
                    // 进到循环之后，先判断两个节点是否相等，
                    // 解决了头结点就是入口节点的问题。
                    if (q == p) {
                        return q;
                    }
                    p = p.next;
                    q = q.next;
                }
            }
        }
        return null;
    }