代码随想录leetcode刷题Day07-链表完结+链表复习（部分）

/*
142. 环形链表 II
给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，则返回null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。
 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。
 */

/*
时间复杂度O(2n) = O(n),空间复杂度O(1)
处理题目的逻辑：
定义一个快指针一个慢指针，从head开始遍历，快指针一次走2下，慢指针走1下
如果有环，快慢指针一定会相遇，而且一定会在环里相遇，且此时慢指针不会完成环的第一圈遍历
这样可以得到两环的相遇位置，从而判断是否有环

之后经过数学推导可得，从head到入环节点的长度等于相遇节点到入环节点的长度
因此更换一个指针的位置，让两个指针都每次向前走一步，即可找到入环节点
 */
class Solution {
    public ListNode detectCycle(ListNode head) {
        if (head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                ListNode meet = fast;
                ListNode temp1 = head;
                ListNode temp2 = meet;
                while (temp1 != temp2){
                    temp1 = temp1.next;
                    temp2 = temp2.next;
                }
                return temp1;
            }
        }
        return null;
    }
}

//思路一样，小小优化一下代码
class Solution1 {
    public ListNode detectCycle(ListNode head) {
        if (head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast.next != null && fast.next.next != null){
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow){
                fast = head;
                while (fast != slow){
                    fast = fast.next;
                    slow = slow.next;
                }
                return slow;
            }
        }
        return null;
    }
}

class ListNode{
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
        next = null;
    }
}


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

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        //定义一个虚拟头节点，这样可以不用单独讨论head
        ListNode virNode = new ListNode(-1, head);
        ListNode temp = virNode;
        while (temp.next != null) {
            if (temp.next.val == val) {//找到了要删除的
                temp.next = temp.next.next;//删除
            } else {//没有找到
                temp = temp.next;//向下继续遍历
            }
        }
        return virNode.next;//头节点可能改变，直接返回虚拟节点的下一个节点即可
    }
}

/*
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 个节点。
 */

class MyLinkedList {

    int size;
    ListNode head;

    public MyLinkedList() {
        head = new ListNode();
    }

    public int get(int index) {
        if (index < 0 || index > size - 1){
            return -1;
        }
        ListNode temp = head;
        for (int i = 0; i < index + 1; i++) {
            temp = temp.next;
        }
        return temp.val;
    }

    public void addAtHead(int val) {
        size++;
        ListNode node = new ListNode(val);
        node.next = head.next;
        head.next = node;
    }

    public void addAtTail(int val) {

        ListNode node = new ListNode(val);
        ListNode temp = head;
        for (int i = 0; i < size; i++) {
            temp = temp.next;
        }
        node.next = null;
        temp.next = node;
        size++;
    }

    public void addAtIndex(int index, int val) {
        if (index > size){
            return;
        }
        size++;
        if (index < 0){
            index = 0;
        }
        ListNode node = new ListNode(val);
        ListNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        node.next = temp.next;
        temp.next = node;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size){
            return;
        }
        size--;
        ListNode temp = head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.next = temp.next.next;
    }
}


/*
206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
 */
class Solution1 {
    public ListNode reverseList(ListNode head) {
        ListNode p = null;
        ListNode c = head;
        ListNode temp;
        while (c != null){
            temp = c.next;
            c.next = p;
            p = c;
            c = temp;
        }
        return p;
    }
}


class ListNode {
    int val;
    ListNode next;

    ListNode() {
    }

    ListNode(int val) {
        this.val = val;
    }

    ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}