算法笔记：链表

算法笔记：有关于链表的题

1.一般思想

1. 建立一个虚拟头结点prehead，以减少边界判断条件，最后如果答案要返回整个链表，那么就return prehead.next。
2. 使用pre代表符合题意的有效链表的结尾，当在循环中再一次选到符合题意的节点head后，pre->next = head；pre = pre->next。
3. 由上一点可知，我们遍历整个链表是通过head指针不断的向后移动，pre也在不断的移动，所以返回时需要用到虚拟头结点，虚拟头结点指向第一个符合题意的节点。

2.实际应用

---

1. LeetCode21：合并两个升序链表

/**
 * 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; }
 * }
 */
 //pre始终为已排好序的最后一个节点，而l1,l2指向的是待比较的两个节点，哪个比较小那么pre就指向哪个，然后更新pre
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode pre = prehead;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val){
                pre.next = l1;
                l1 = l1.next;
            }else{
                pre.next = l2;
                l2 = l2.next;
            }
            pre = pre.next;
        } 
        pre.next = l1 == null ? l2 : l1;
        return prehead.next;
    }
}

①初始时，建立虚拟头结点prehead，指针pre指向虚拟头结点，之后进入循环。
②然后找一下链接的条件（pre要指向符合题意的节点），由于是升序链表，可知我们只要两两比较两个链表节点的大小，选出最小的那个就是符合题意的节点，pre指向选出的节点，pre后移。
③边界条件是两个节点都不为空，退出循环时，l1或l2最多有一个非空，我们再把pre指向最后非空的那个链表，返回prehead.next即可。

---

2. LeetCode82. 删除排序链表中的重复元素 II

存在一个按升序排列的链表，给你这个链表的头节点 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 deleteDuplicates(ListNode head) {
        ListNode prehead = new ListNode(-1);
        ListNode pre = prehead;
        while(head!=null){   
            if(head.next==null||head.val!=head.next.val){
            pre.next = head;
            pre = pre.next;
            } 
            while(head.next!=null&&head.val==head.next.val){
                head = head.next;
            }
            head = head.next;
        }
        pre.next = null;  
        return prehead.next;
    }
}

①初始时，建立虚拟头结点prehead，指针pre指向虚拟头结点，之后进入循环。
②找符合题意的节点。找一下链接的条件（pre要指向符合题意的节点），符合题意的节点是数字不重复的节点，即这个节点和它的下一个节点的值不相等，那么可以轻松得到判断条件head.val!=head.next.val，再考虑到如果这个节点是最后一个节点，那么它的下一个节点为null，必不相等，所以可以得到条件：head.next==null||head.val!=head.next.val。
之后pre指向选出的节点，pre后移。
③处理不符合题意的节点。不符合题意的节点满足head.next!=null&&head.val==head.next.val；要把不符合题意的节点全部跳过，即head = head.next。
④处理pre最后的指向问题。

注意：1.上面的head.next==null||head.val!=head.next.val和head.next!=null&&head.val==head.next.val ||和&&左右两边不能写反，否则会发生空指针异常（因为||和&&都有短路效果）。2.pre最后要指向null。

---

3. LeetCode83：删除排序链表中的重复元素
存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。返回同样按升序排列的结果链表。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode prehead = new ListNode(-1);
        ListNode pre = prehead;
        while(head!=null){
            pre.next = head;
            pre = pre.next;
            head = head.next;           
            while(head!=null&&head.val==pre.val){
                head = head.next;
            }
        }
        pre.next = null;
        return prehead.next;
    }
}

①初始时，建立虚拟头结点prehead，指针pre指向虚拟头结点，之后进入循环。
②找符合题意的节点。首先第一个节点可以先加入pre，head向后遍历，把与pre相同的节点都删除（head.val==pre.val），即下一个与pre不同的节点为符合题意的节点。之后pre指向选出的节点，pre后移。
③处理pre最后的指向问题。

注意：这种头结点不像上一题需要判断是否符合题意，必会加入最终链表的题其实无需建立虚拟头结点，只不过为了不被链表绕晕，加上更容易理解。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return head;
        }

        ListNode cur = head;
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }

        return head;
    }
}