【刷题日记】Day2.链表（合并两个有序链表、链表相交、删除链表的倒数第 N 个结点）

本文链接：https://blog.csdn.net/Superkom666/article/details/129582243

合并两个有序链表

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

题解：这题我们使用迭代的思想来解决这道题目

我们的目标是合并以后这个链表仍然是升序排列的，那么我们的思路就是先创建一个虚拟头节点，然后不断地对两个链表的节点进行比较，哪一个更小就添加到新的链表中去

所以代码的思路就是使用while循环来同时遍历两个链表，当某一个链表遍历完了那么循环也就结束了

        while(cur1 != null && cur2 != null){
            if(cur2.val >= cur1.val){
                tmp.next = cur1;
                cur1 = cur1.next;
            }else{
                tmp.next = cur2;
                cur2 = cur2.next;
            }
            tmp = tmp.next;//一定要记得让新链表的指针向后移动，不然就无法添加新的节点了
        }

假如我们两个链表中的某一条链表已经遍历完了，还剩一个链表(该链表并没有遍历完毕)，那么我们就应该直接将这个链表剩下的所有节点都添加到新链表中去，因为链表是升序排列的，所以我们不用担心后续的链表并不是升序的问题

        if(cur1 != null){
            while(cur1 != null){
                tmp.next = cur1;
                cur1 = cur1.next;
                tmp = tmp.next;
            }
        }
        
        if(cur2 != null){
            while(cur2 != null){
                tmp.next = cur2;
                cur2 = cur2.next;
                tmp = tmp.next;
            }
        }

最后贴上完整代码

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummyhead = new ListNode(0);
        ListNode tmp = dummyhead;
        ListNode cur1 = list1;
        ListNode cur2 = list2;
        
        while(cur1 != null && cur2 != null){
            if(cur2.val >= cur1.val){
                tmp.next = cur1;
                cur1 = cur1.next;
            }else{
                tmp.next = cur2;
                cur2 = cur2.next;
            }
            tmp = tmp.next;
        }
        
        if(cur1 != null){
            while(cur1 != null){
                tmp.next = cur1;
                cur1 = cur1.next;
                tmp = tmp.next;
            }
        }
        
        if(cur2 != null){
            while(cur2 != null){
                tmp.next = cur2;
                cur2 = cur2.next;
                tmp = tmp.next;
            }
        }
        
        return dummyhead.next;
    }
}

链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题解：这题我们使用双指针的思想来解决

我们假设一个快指针一个慢指针，当两个链表长度不一样的时候，让快指针走完两条链表相差的长度，然后快慢指针同时走，当两个指针相遇的时候那么就可以证明这个链表是相交的，假如两个链表没有相遇那么也就说明这个链表是没有相交的

有了具体的思路我们就可以完成我们的代码了

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {

        ListNode first = headA;
        ListNode second = headB;

        int A = 0;
        while(first != null){
            first = first.next;
            A++;
        }

        int B = 0;
        while(second != null){
            second = second.next;
            B++;
        }

        //重置一下两个指针
        first = headA;
        second = headB;

        int n = Math.abs(A-B);

        if(A > B){
            while(n != 0 && first != null){
                first = first.next;
                n--;
            }
        }else{
            while(n != 0 && second != null){
                second = second.next;
                n--;
            }
        }

        while(first != second){
            first = first.next;
            second = second.next;
        }

        return first;
    }

这里要注意的是在算完两条链表的长度以后，我们要将两个指针重置，不然的话两个指针会一直指向null，后续的操作也无法进行了

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

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

题解：我们想要删除某一个节点，那么就要找到这个节点的前一个节点然后再进行删除操作，由于题目说的是倒数第n个节点，那么我们就使用快慢指针来进行操作，将倒数第n个节点转换成正数的第n节点，具体操作就是让快指针先走n步然后快慢指针同时向后走，当快指针指向null时，慢指针也就指向了倒数第n个节点。由于我们要找的是第n个节点的前一个节点，所以我们让快指针走n+1步，这样我们的慢指针就相当于是少走了一步，这样就能够找到我们的前一个结点了

同时我们使用虚拟头节点的方式来解决链表的题目，目的是为了避免对头节点是否存在进行讨论。由于头节点可能存在是否存在以及是否链表只有头节点这一个节点的情况，我们使用虚拟头节点的方法，无论头节点是否存在，我们都可以保证整个链表至少存在一个节点的情况，这样就很好的避免了对头节点的情况进行讨论，简化我们的代码量

最后贴上完整代码

    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyhead = new ListNode(0);
        dummyhead.next = head;

        ListNode slow = dummyhead;
        ListNode fast = dummyhead;

        while(n+1 != 0){
            fast = fast.next;
            n--;
        }

        while( fast != null){
            slow = slow.next;
            fast = fast.next;
        }
        
        slow.next = slow.next.next;
        
        return dummyhead.next;
    }