代码随想录leetcode刷题Day06-链表

/*
206. 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
 */

//使用双指针法完成链表的反转
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp;
        while (cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

/*
24. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。
你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
 */
class Solution {
    public ListNode swapPairs(ListNode head) {

        //如果链表没有节点或只有一个头节点，直接返回，不翻转
        if (head == null || head.next == null){
            return head;
        }

        //设置一个虚拟头节点，这样不用单独讨论头节点
        ListNode virNode = new ListNode(0,head);

        ListNode p = virNode;
        ListNode c = head;

        //如果c为null，退出循环
        while (c != null){
            ListNode temp = c.next.next;
            p.next = c.next;
            c.next.next = c;
            c.next = temp;
            //提前退出循环
            if (temp == null && temp.next == null){
                return virNode.next;
            }
            p = c;
            c = temp;
        }
        return virNode.next;
    }
}

/*
19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
 */

//方法一：两次循环遍历
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null) {
            return null;
        }

        ListNode virNode = new ListNode(0, head);//定义一个虚拟头节点
        int count = 0;
        ListNode temp = virNode;
        while (temp.next != null) {
            temp = temp.next;
            count++;
        }//得到链表的长度count
        temp = virNode;
        for (; count > n; count--) {
            temp = temp.next;
        }//循环count - n次，使temp指向要删除节点的前一个节点
        temp.next = temp.next.next;//删除节点
        return virNode.next;//注意头节点可能被删除，因此直接返回虚拟节点的next即可
    }
}

//方法二：很妙的双指针
class Solution1 {
    public ListNode removeNthFromEnd(ListNode head, int n) {

        if (head == null){
            return null;
        }
        ListNode virNode = new ListNode(0,head);
        ListNode fast = virNode;
        ListNode slow = virNode;//设置一个快指针一个慢指针，最开始都指向虚拟节点

        while (n > 0){
            fast = fast.next;
            n--;
        }//先让快指针移动n步
        while (fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }//然后让快指针和慢指针同时移动，当快指针移动到链表末尾时，慢指针位于要删除节点的前一个
        slow.next = slow.next.next;//删除节点
        return virNode.next;//注意头节点可能被删除，因此返回虚拟节点的下一个即可
    }
}


/*
160. 相交链表
给你两个单链表的头节点 headA 和 headB ，
请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
 */

class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = getLen(headA);
        int lenB = getLen(headB);
        ListNode t1 = headA;
        ListNode t2 = headB;
        if (lenA < lenB) {
            int n = lenB - lenA;
            while (n > 0) {
                t2 = t2.next;
                n--;
            }
        } else {
            int n = lenA - lenB;
            while (n > 0) {
                t1 = t1.next;
                n--;
            }
        }
            while (t2 != null) {
                if (t1 == t2) {
                    return t2;
                }
                t1 = t1.next;
                t2 = t2.next;
            }
            return null;
        }

    private static int getLen(ListNode head){
        ListNode temp = head;
        int len = 0;
        while (temp != null){
            temp = temp.next;
            len++;
        }
        return len;
    }

}

class Solution1 {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}