代码随想录-链表2-5

203.移除链表元素

题目

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

代码

/**
 * 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 removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1,head);
        ListNode pre = dummy;
        ListNode cur = head;
        while(cur != null){
            if(cur.val == val){
                pre.next = cur.next;
                cur = cur.next;
            }
            else{
                pre = pre.next;
                cur = cur.next;
            }
        }
        //return head; //会报错,因为第一个节点被删除时，head指向的内存已经不是当前真实的head了
        return dummy.next;

    }
}

总结

1.原理

        需要创造虚拟头结点，方便对头结点删除。创造pre指向前身和cur指向当前节点，遍历列表，访问cur的val值，如果不等于val，pre和cur就一直向后移动，如果等于val，让pre执行cur的下一个节点。直到cur的指针为空结束遍历。

2.算法注意点：

（1）要创造虚拟头结点方便操作；

（2）遍历终止的条件是当前节点cur==null，而不是cur.next==null，因为要对最后一个节点进行访问判断的时候，cur.next已经是空了，当最后一个节点访问结束，cur才是空；

（3）最后return的是dummy.next，而不是head，因为dummy一直都是链表的虚拟头结点，而head在链表第一个元素被删除时，就已经不代表链表的头节点了。

3.语法问题

        用null而不是NULL

第二次刷题总结

1.一定要用pre和cur分别指向虚拟头结点和head，不能在原先的dummyhead和head上操作。

2.对循环的结束条件理解的更透彻了，因为pre指向的是删除元素的前一个，而cur指向的是当前被访问的元素，而cur需要从头相后访问链表的每一个节点，说白了cur就是对链表进行遍历的，一个元素都不能少，因次循环结束条件是cur != null。

3.if和else内部的指针修改要谨慎，pre和cur不能乱指。

        如果cur等于val，pre.next=cur.next。此时pre不用再后移了，cur后移指向下一个访问元素就行，因为cur元素被删除，pre代表的还是被访问元素的前一个。

        如果cur不等于val，才让pre后移+cur后移。

        其实cur后移是if和else都要执行的操作，放在判断语句外边写一次也行，因为cur的作用就是一直从头往后访问每一个链表的元素。只有pre的操作会因为cur值等不等于val发生变化，如果不等于，pre直接像cur一样后移。如果相等，要把cur元素去掉，执行pre.next=cur.next就行了。千万不要多写pre=pre.next了，多此一举。

4.函数返回值一定是dummyhead.next，不能是head，因为head可能在链表被修改后，已经不是新链表的head。而只有dummyhead，不会被删除，永远是虚拟头结点，能指向链表的入口。

707.设计链表

题目

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

代码（单链表）

/**
 * 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 MyLinkedList {

    int size;
    ListNode dummyhead;

    public MyLinkedList() {
        size = 0;
        dummyhead = new ListNode(-1,null); //虚拟头结点
    }
    
    public int get(int index) {
        if(index < 0 || index >= size){
            return -1;
        }
        ListNode cur = dummyhead.next;
        while(index-- > 0){
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        if(index <0 ||index > size){
            //return -1; 不能这样写
            return;
        }
        ListNode pre = dummyhead;
        ListNode addto = new ListNode(val);
        while(index-- > 0){
            pre = pre.next;
        }
        addto.next = pre.next;
        pre.next = addto;
        size++;
    }

    
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size ){
            //return -1; 不能这样写
            return;
        }
        ListNode pre = dummyhead;
        while(index-- > 0){
            pre = pre.next;
        }
        pre.next = pre.next.next;
        size--;

    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

总结

1.原理

（1）获取下标为index的元素：先判断index不满足的情况，返回-1。cur指向index=0的节点，即dummyhead.next，当index大于0时，cur一直往后走，最后返回cur.val。如何确定循环条件是index-->0,假设index等于0时，判断是不是返回了index=0的元素。

（2）在index节点前插入新节点：先判断index不满足的情况，注意是直接return，不是return-1，void函数没有返回值。在让pre指向虚拟头结点，当index大于0时。pre一直往后走，关键是找到当前index节点的前一个pre。找到后让新节点指向pre.next，让pre指向新节点。最后别忘了size++。此函数无返回值。如何确定循环条件是index-->0,假设index等于0时，判断是不是在index=0前插入了新元素。

（3）删除index的元素：先判断index不满足的情况，直接return。关键是找到index节点的pre，修改pre的指针。所以让pre指向虚拟头结点，当index-->0时，pre一直往后走，找到index后，让pre.next =pre.next.next。最后别忘了size--，函数无返回值。

2.语法规则

        int size和ListNode dummyhead的声名要写在构造函数外面，而自定义构造函数MyLinkedList里面只用对其进行初始化，不用声明类型。

第二次刷题总结

1.直接通过了。就是要明白这一题我们要自定义一个链表，里面有size和虚拟头结点，并要用够咱函数进行初始化令size=0，dummyhead = new ListNode(-1,null)

2.get函数核心是cur。因为get函数要返回第index节点，我们就让cur从第一个节点开始，不断靠近返回的节点值，index多大，cur就走多少步，最后cur指向的就是要返回的节点，进行return cur.val即可。（极限理解，index=0，cur不用走，直接return了）

3.addAtIndex要在index节点前插入，所以我们要用pre指向插入节点的前一个节点。核心是pre，从虚拟头节点开始，不断靠近插入节点的前一个节点，index多大，pre就走多少分，最后的pre执行插入节点的前一个节点。然后执行插入，size++。（极限理解1，index=0，pre不用走，直接插入到第一个节点的位置。极限理解2，index=链表长度，pre正好走到最后一个节点，然后新增节点插入的末尾）

4.deleteAtIndex,要删除第index元素，核心是pre，用于指向待删除节点的前一个节点。index多大，pre走几步，不断靠近被删除节点的前一个节点。然后执行删除，size--。（极限理解，index=0，pre不用走，直接删除第一个节点）

206.反转链表

题目

        给你单链表的头节点 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 reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode tmp; //保存后一个节点的指针
        while(cur != null){
            tmp = cur.next; //保存后一个节点的指针
            cur.next = pre; //反转当前节点的指针
            pre = cur;  //不能写pre.next
            cur = tmp ;  //不能写cur.next
        }
        return pre;

    }
}

总结

1.原理

        将链表的指针从前往后逐个反转。先定义pre为null，cur为当前节点，tmp保存cur的后续节点。当cur不为空时，先保存cur的后续为tmp，再让cur翻转指向pre即翻转完成。最后把pre修改为cur，cur修改为tmp。

2.注意点

（1）最后函数的返回值是pre，翻转结束后，pre正好对应最后一个节点。

（2）循环终止条件是cur!=null，因为在翻转最后一个节点时，cur指向最后一个节点，此时cur还不是空，只有当最后一个节点也翻转完成，pre指向最后一个节点，cur指向空。

（3）前进pre和cur时，不能用next，而是直接修改为cur和tmp，因为翻转后指针已经变化了。

第二次刷题总结

没有一次通过，写了下面的错误代码。

//ListNode dummyhead = new ListNode(-1,head);
        //ListNode pre = dummyhead;
        ListNode pre = null;

1.这里用不了虚拟头结点

        第一个节点翻转之后直接指向空就行，如果令pre = dummyhead，cur = head，然后翻转第一个节点后，第一个节点指向就不是null了，而是dummyhead，就会虚拟头结点和第一个节点就会形成一个环，完全多此一举。

2.更加理解了pre、cur、tmp的作用

        pre指代的是翻转节点的前一个节点（翻转后要在指向的地址），cur指代的是当前需要被翻转指针的节点，tmp指代的是翻转前的下一个节点。

        因此，每翻转完一次，pre要指向cur，cur要指向tmp。而且，因为cur遍历的是每一个待翻转的节点，所以循环终止的条件明显就是cur！=null。最后，跳出循环时，pre指向的是最后一个节点，cur已经为空了，所以return pre。

24.两两交换链表中的节点

题目

        给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

代码

/**
 * 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 swapPairs(ListNode head) {
        ListNode dummyhead = new ListNode(-1,head);
        ListNode pre = dummyhead;
        ListNode fisrtnode,secondnode,tmp;
        while(pre.next != null && pre.next.next != null){
            fisrtnode = pre.next; //结点1
            secondnode = pre.next.next; //节点2
            tmp = pre.next.next.next; //节点3
            pre.next = secondnode;  //虚拟头指针指向2 
            secondnode.next = fisrtnode; //2指向1
            fisrtnode.next = tmp;  //1指向3
            pre = pre.next.next;
        }
        return dummyhead.next;

    }
}

总结

1.原理

        两个节点一对逐对翻转，如果是奇数个节点最后一个节点不用管。那么如何翻转头两个节点呢，首先创建虚拟头结点，令pre指向dummyhead，让fisrt，second，tmp分别指向节点1,2,3。令pre执行节点2，节点2指向节点1，节点1指向tmp结点3，然后把pre向后移动两个节点，即指向节点2，再开始修改3,4，依次进行下去，直到遍历完链表。最后返回头结点指针dummyhead.next。

2.注意点

（1）要创建虚拟头结点，先要存储好节点1,2,3后，再依次修改pre-2-1-3.

（2）如何确定循环结条件，当pre后边没有节点or只有一个节点就不需要再遍历了，即循环终止时满足pre.next == null ||  pre.next.next == null。所以循环进行的条件是while(pre.next != null && pre.next.next != null)。

        特别主要&&前后两个不能交换，因为如果最后没有节点，pre.next != null判断失败，直接结束while，而此时pre.next.next 压根没有这个指针不，会编译失败

（3）最后返回的是dummyhead.next.

第二次刷题总结

/**
 * 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 swapPairs(ListNode head) {
        ListNode dummyhead = new ListNode(-1,head);
        ListNode pre = dummyhead;
        ListNode first;
        ListNode second;
        ListNode tmp;
        while(pre.next != null && pre.next.next != null){
            first = pre.next;
            second = pre.next.next;
            tmp = pre.next.next.next;

            pre.next = second;
            second.next = first;
            first.next = tmp;

            pre = pre.next.next;

        }
        return dummyhead.next;

    }
}

1.核心还是要理解pre，first，second，tmp的作用。

        pre初始值是虚拟头结点，然后每次都指向被翻转的两个节点的前面一个节点。

        first指向被翻转的第一个节点。

        second指向被翻转的第二个节点。

        tmp用于保存第三个节点的地址。

2.这次循环条件(pre.next != null && pre.next.next != null）写错了，少了一个next，因为写代码的时候没理解好pre指向的是被翻转的两个节点的前面一个节点。

        循环结束有2种情况，一种是偶数个节点，假设是4个，翻转完2轮后，pre指向的是节点4，这时pre.next为null。一种是奇数个节点，假设是5个，翻转完2轮后，pre指向的是节点4，这时pre.next.next是空为null。

        其实粗暴理解就是，只要pre后边有两个节点，就能进入循环。