[Leetcode刷题]——链表

一、找出两个链表的交点

160.相交链表（easy）2021-01-05

编写一个程序，找到两个单链表相交的起始节点    

如下面的两个链表，在c1 处相交：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode l1 = headA;
        ListNode l2 = headB;
        while(l1 != l2){
            l1 = (l1 == null) ? headB : l1.next;
            l2 = (l2 == null) ? headA : l2.next;
        }
        return l1;
    }
}

解法：如果两个链表有相交，设第一个链表长度为 a+c, 第二个链表长度为b+c。

　　让两个链表指针从头开始遍历，第一个链表遍历a+c后接着从头开始遍历第二个链表的b，第二个链表遍历b+c后从头开始遍历第二个链表的a。

　　最后两个指针会同时到达相交的地方。

　　注意，条件判断时判断的是（l1 == null）而不是 (l1.next == null) 。其目的是为了如果两个链表没有相交，那么在遍历两个链表后连个指针均指向了链表最后的null，而非陷入死循环。

　　此解法的复杂度为O(n)。

二、反转链表

　　206.反转链表（easy）2021-01-06

　　反转一个单链表。

　　示例:

    　输入: 1->2->3->4->5->NULL

　　输出: 5->4->3->2->1->NULL

　　进阶：
　　你可以迭代或递归地反转链表。你能否用两种方法解决这道题？

　　我的原始解法，错误示范：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode newHead = head;
        newHead.next = null;
        ListNode traverseNode = head;
        while(traverseNode.next != null){
            traverseNode = traverseNode.next;
            ListNode temp = traverseNode;
            temp.next = newHead;
            newHead = temp;
        }
        return newHead;
    }
}

　

错误分析：上述代码理论推导似乎可行，但是编译器运行不通过。

　　　　　debug后发现，第2-5行，将head结点赋值给newhead结点，然后将newhead结点的next指针改为null，发现原始的head结点的next指针自动也变成了null。

　          　在idea中可以看到，虽然head的值赋值给newHead 和traverseNode, 但是并没有开辟新空间，所以这里不能当一般变量处理。

标准解法：

1.递归，yyds

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

2.头插法

public ListNode reverseList(ListNode head) {
    ListNode newHead = new ListNode(-1);
    while (head != null) {
        ListNode next = head.next;
        head.next = newHead.next;
        newHead.next = head;
        head = next;
    }
    return newHead.next;
}

 三、合并两个有序链表

21、合并两个有序链表(easy) 2021-01-07

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

我的代码：

常规思路，需要注意的是在进行循环后的第二个if 语句时，又重新判断了( l1 != null )。 如果不加判断条件有可能为null就直接写l1.val会产生NullPointerException异常。

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode(-1);
        ListNode temp = newHead;
        while(l1 != null && l2 != null){
            if(l1.val < l2.val){
                temp.next = l1;
                temp = l1;
                l1 = l1.next;
            }
            if(l1 != null && l2.val <= l1.val){
                temp.next = l2;
                temp = l2;
                l2 = l2.next;
            }
        }
        if(l1 == null){
            temp.next = l2;
        }
        if(l2 == null){
            temp.next = l1;
        }
        return newHead.next;
    }
}

递归的写法，真简洁：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null) return l2;
    if (l2 == null) return l1;
    if (l1.val < l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
}
}

四、从有序链表中删除重复结点

83、删除排序链表中的重复元素   (easy)  2021-01-08

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

示例 1:

输入: 1->1->2
输出: 1->2
示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

我的解法：需要注意的一点是在没有判断结点是否为空的情况下之直接就使用.val 调用结点的数值会报NullPointerException异常

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode tempNode = head;
        while(tempNode != null){
            if(tempNode.next != null && tempNode.val == tempNode.next.val){
                tempNode.next = tempNode.next.next;
            }else{
                tempNode = tempNode.next;
            }
        }
        return head;
    }
}

递归的解法，妙呀，三行就搞定！唯一不足的就是内存消耗较多。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) return head;
    head.next = deleteDuplicates(head.next);
    return head.val == head.next.val ? head.next : head;
}
}

 五、删除链表的倒数第N个结点

19、给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。(medium) 2021-01-09

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

我的解法，遍历两次，内存击败29.8%，还是太菜

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
         ListNode tempNode = head;
         int len = 1;
         while(tempNode.next != null){
             len++;
             tempNode = tempNode.next;
         }
         tempNode = head;
         if(n == len){
             return head.next;
         }else{
             while(tempNode != null && tempNode.next != null){
                 if(len == n + 1){
                     tempNode.next = tempNode.next.next;
                  }
                 len--;
                 tempNode = tempNode.next;
             }
             return head;
         }

    }
}

遍历一次的原理，设置两个指针，让一个指针先走n长度，然后两个指针一起走，当快的指针走到链表结尾时，慢的指针就在倒数第n个位置

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode fast = head;
    while (n-- > 0) {
        fast = fast.next;
    }
    if (fast == null) return head.next;
    ListNode slow = head;
    while (fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return head;
    }
}

六、两两交换链表中的相邻结点

24、给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。(medium) 2021-01-10

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

解法：力扣里的链表的头节点都是第一个结点，在这个题中，设置第一个结点的前一个结点为头结点，在判断后两个结点是否为空，然后进行交换即可。

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode preHeadNode = new ListNode(-1);
        preHeadNode.next = head;
        ListNode traverseNode = preHeadNode;
        while(traverseNode.next != null && traverseNode.next.next != null){
            ListNode n1 = traverseNode.next;
            ListNode n2 = traverseNode.next.next;
            traverseNode.next = n2;
            ListNode temp = n2.next;
            n2.next = n1;
            n1.next = temp;
            traverseNode = n1;
        }
        return preHeadNode.next;
    }
}

　　递归的写法，需要系统的学习递归，链表和树的大多数题目太适合递归了。

　　参考博客https://lyl0724.github.io/2020/01/25/1/

　　递归三部曲：1.找终止条件 2.找返回值 3.单次过程

class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }
}