代码随想录-链表

链表解题经典三板斧，哑巴节点，栈，快慢指针。哑巴节点一般是为了处理头尾节点用的，因为这边逻辑有区别，有时候会让代码变得比较长。但其实用指针+边界判断也行。这题因为逻辑简单，其实不用哑巴节点，直接用指针也行。 栈的话这题意义不大，你入栈一次不也就拿到长度了。而且对链表，pop意义不大。官方还创建了两次节点，我寻思用指针就可以了，官方这个内存消耗估计不低。 至于快慢指针，虽然少了一次常量遍历，但每次操作要操作两个指针，也快不了多少。总之就是为了解题而解题吧。但是这几个方法确实都是链表解题利器。面试的时候用上，基本题目都难不倒，跑起来不说，至少思路可以掰扯出来。 附上不用哑巴节点的方法。我感觉这题够用了

链表的定义

默认定义好，自己手撕容易忘

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

移除链表

方法一：使用虚拟节点
ListNode newHead = new ListNode(-1,head);
pre.next=cur.next;
方法二：不使用虚拟节点
记住是while不是if，可能存在连续个头节点为val
while (head != null && head.val == val) {
head = head.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 removeElements(ListNode head, int val) {
        // //使用虚拟节点
        // if(head==null){
        //     return head;
        // }
        // ListNode newHead = new ListNode(-1,head);
        // ListNode pre = newHead;
        // ListNode cur = head;
        // while(cur!=null){
        //     if(cur.val==val){
        //         pre.next=cur.next;
        //     }else{
        //         pre=cur;
        //     }
        //     cur=cur.next;
        // }
        // return newHead.next;

        //不使用虚拟节点
        //记住是while不是if，可能存在连续个头节点为val
        while (head != null && head.val == val) {
            head = head.next;
        }
        if(head==null){
            return head;
        }
        ListNode pre=head;
        ListNode cur=head.next;
        while(cur!=null){
            if(cur.val==val){
                pre.next=cur.next;
            }else{
                pre=cur;
            }
            cur=cur.next;
        }
        return head;

    }
}

设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。
【高亮】先用单链表/双链表定义一个head！！！！

    int size;
    ListNode head;

addAtIndex的问题
//加到index-1的节点之后  
//不能用while(count==index-1)  
//用for  i<index

class MyLinkedList {
    int size;
    ListNode head;
    public MyLinkedList() {

    }
    
    public int get(int index) {

    }
    
    public void addAtHead(int val) {

    }
    
    public void addAtTail(int val) {

    }
    
    public void addAtIndex(int index, int val) {

    }
    
    public void deleteAtIndex(int index) {

    }
}

反转链表（用stack更快）

pre
cur
tmp
遍历链表
pre cur,tmp
null 1,||,2,3,4,5
1,null 2,||,3,4,5
2,1,null 3,||,4,5
4,3,2,1,null 5
5,4,3,2,1,null

        while(cur!=null){
            tmp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=tmp;
            if(cur==null){break;}
        }

ListNode pre=null;
不能用ListNode pre=new ListNode();
new默认0

两两交换

cur,node1,node2
这样写比较明了
不要一直cur, cur.next, cur.next.next太乱了
node1=cur.next;
node2=cur.next.next;

链表相交

数学追及问题
遍历完自己的，去走对面的，两个相遇的时候，就是第一个相交的点

怎么判断不相交，怎么确定停止条件

检查当前节点是否为null
而不是检查next是否为null

因为两个同时为null的时候，就是停止的时候

因为保障了相交节点之后全一致
所以不会出现两个链表数量相同，但是共同节点出现的位置不同的情况

        ListNode A = headA, B = headB;
        while (A != B) {
            A = A != null ? A.next : headB;
            B = B != null ? B.next : headA;
        }
        return A;

删除链表倒数第n个节点

快慢指针，类窗口
fast==null的时候
slow再和fast一起动

[ 用时: 26 m 8 s ]
当next为null的时候，不能fast=fast.next;
但可以fast=null

环形链表

追及问题
fast两步两步走
slow一步一步走
fast==slow
p2=fast;相遇节点

找环入口：
p1 头节点
p2 相遇节点
p1，p2同时走，相遇时就是入口