Leetcode刷题--链表

基本内容

链表知识点总结：
(1)内存地址不是连续的。
(2)包含数据域 和 指针。
(3)更加适合于增删。增删是O(1)。查询速度慢，查询是O(n)。

Leetcode 题目

类型一 删除元素

第1题： 203. 移除链表元素

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

思路：在操作链表的时候，非常重要的一个点就是要学会使用虚拟的头结点，这样可以省去很多麻烦。有了虚拟头结点之后，所有的节点都可以使用同一个逻辑进行处理。
需要删除链表的元素，那么需要找到 待删除节点的前一个节点，然后将节点的前一个指针指向下下个节点。

题解：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //使用虚拟头节点。 移除元素的时候要找到删除节点的前一个位置，虚拟头结点可以处理头结点就是删除节点的特殊情况
        ListNode fakeHead = new ListNode(0, head);
        //辅助指针
        ListNode temp = fakeHead;

        //遍历链表
        while(temp.next != null){
            if(temp.next.val == val){
                //删除的时候，辅助指针不动
                temp.next = temp.next.next;
            }else{
                //更新辅助指针
                temp = temp.next;
            }
        }

        return fakeHead.next;
    }
}

类型二 链表设计

第1题： 707. 设计链表

题目描述： 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

思路：如何设计节点和链表问题。节点需要有value和next。链表最好设计一个虚拟头结点，这样很多问题才比较方法，再添加一个节点的数量。

题解：

class MyLinkedList {
    //链表虚拟头结点，要返回链表头节点的时候，返回 head.next
    Node head;
    //链表节点数量
    int size;

    public MyLinkedList() {
        head = new Node(0, null);
        size = 0;
    }
    
    //这里的index是下标，下标是0才返回第一个
    public int get(int index) {
        //异常判断
        if(index < 0 || index > size - 1){
            return -1;
        }

        //创建辅助节点
        Node temp = head;
        for(int i = 0; i <= index; ++i){
            temp = temp.next;
        }

        return temp.val;
    }
    
    //在头结点处添加一个节点
    public void addAtHead(int val) {
        //创建节点
        Node newNode = new Node(val, head.next);

        //虚拟头节点指向他
        head.next = newNode;
        size++;
    }
    
    //在尾部添加，先找到最后一个节点
    public void addAtTail(int val) {
        //创建辅助节点
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;  //此时temp就是指向最后一个节点
        }

        Node newNode = new Node(val, null);
        temp.next = newNode;
        size++;
    }
    
    //在指定下标位置添加元素
    public void addAtIndex(int index, int val) {
        //大于的情况
        if(index > size) return;
        //小于的情况
        if(index < 0){
            index = 0;
        }
        //辅助节点
        Node temp = head;
        for(int i = 0; i < index; ++i){
            temp = temp.next;
        }
        //插入节点
        Node newNode = new Node(val, temp.next);
        temp.next = newNode;
        size++;
    }
    
    //删除指定位置的节点
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size) return;

        //辅助节点，找到待删除节点的前一个节点
        Node temp = head;
        for(int i = 0; i < index; ++i){
            temp = temp.next;
        }

        //删除
        temp.next = temp.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);
 */
 //链表节点
 class Node{
     int val;
     Node next;

    //构造方法
    public Node(){}
    public Node(int v, Node n){
        val = v;
        next = n;
    }
 }

类型三 反转链表

第1题： 206. 反转链表

题目描述：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：这个题总是做了忘。。。关键点在于，需要多个辅助指针，掌握反转的逻辑。
要反转链表，应该想到 pre 和 cur 指针，每次反转的时候，让当前指针next指向pre，但需要注意，应该将cur的next先保存下来，不然在遍历的过程会丢失信息。

题解：

class Solution {
    public ListNode reverseList(ListNode head) {
        //辅助节点
        ListNode cur = head;
        ListNode pre = null;

        while(cur != null){
            //保存下个节点，才找得到
            ListNode curNext = cur.next;
            //修改当前节点的next指针，指向前一个节点
            cur.next = pre;
            //更新pre指针
            pre = cur;
            //更新cur
            cur = curNext;
        }

        return pre;
    }
}

类型四 交换链表节点

第1题： 24. 两两交换链表中的节点

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

思路：重要的是画图，搞清这个关系，每一步是怎么变化 的。 还有需要一个虚拟头节点，方便很多。使用三个记录指针 1 2 3+ 一个遍历指针 t， 首先，应该更新123，然后t => 2, 2=> 1, 1 => 3。这就是一个完整的过程，最后更新 t 为 1即可。

最后更新cur 为 1。

题解：

class Solution {
    public ListNode swapPairs(ListNode head) {
        //使用虚拟头结点
        ListNode fake = new ListNode(0, head);

        //辅助指针
        ListNode temp = fake;
        ListNode first = null;
        ListNode second = null;
        ListNode third = null;

        while(temp.next != null && temp.next.next != null){
            //保存最后的，以免找不到
            third = temp.next.next.next;
            //更新second
            second = temp.next.next;
            //更新first
            first = temp.next;

            //改变temp的next指针，指向second
            temp.next = second;
            //改变second的next指针，指向first
            second.next = first;
            //改变first的next指针，指向third
            first.next = third;
            //更新temp
            temp = first;
        }

        return fake.next;
    }
}

类型五 删除链表倒数的某个节点

第1题： 19. 删除链表的倒数第 N 个结点

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

思路：可以使用暴力，两次遍历，时间复杂度：O(n^2)。
还能使用双指针，时间复杂度：O(n)。 具体思路： 先让快指针移动 n 步，然后慢指针和快指针一起移动，直至fast走到最后，slow指针就是我们要找的位置了。

题解：

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        //可以使用暴力，时间复杂度O(n^2) 略
        //双指针法，时间复杂度 O(n)

        //创建虚拟头节点
        ListNode fake = new ListNode(0, head);
        ListNode fast = fake;
        ListNode slow = fake;

        //先让快指针移动 n 步，然后慢指针和快指针一起移动，直至fast走到最后，slow指针就是我们要找的位置了
        for(int i = 0; i < n; ++i){
            fast = fast.next;
        }

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

        //删除
        slow.next = slow.next.next;

        return fake.next;
    }
}

类型六 链表相交

第1题： 面试题 02.07. 链表相交

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

思路：方法(1)：使用HashSet来做，时间复杂度O(n+m)。
方法(2)：也可以使用双指针法。 如果链表相交，那么在 交点 之后，两个链表的长度就是相同的。 首先，让长链表移动 long - short 距离，保证遍历这两个链表是同一长度开始的，最后能同时到达一个位置。然后就可以不断循环判断这个是不是相交节点，直至是为止。