刷题篇

• 一、回文链表
• • 1.1 题目描述
  • 1.2 思路分析
  • 1.3 代码演示
• 二、环形链表
• • 2.1 题目描述
  • 2.2 思路分析
  • 2.3 代码演示
• 三、合并两个有序链表
• • 3.1 题目描述
  • 3.2 思路分析
  • 3.3 代码演示

一、回文链表

1.1 题目描述

1.2 思路分析

1.3 代码演示

public boolean isPalindrome(ListNode head) {
        //非空判断
        if (head == null) {
            return false;
        }
        //找到回文链表前一段的最后一个节点
        ListNode firstHalfEnd = endOfFirstList(head);
        //找到回文链表反转后的第一个节点
        ListNode firstHaftStart = reverse(firstHalfEnd.next);
        //设置标记
        boolean result = true;
        //设置遍历指针
        ListNode p1 = head;
        ListNode p2 = firstHalfStart;
        while(result && p2 != null) {
            if(p1.val != p2.val) {
                result = false;
            }
            p1 = p1.next;
            p2 = p2.next;
        }
        //恢复链表
        firstHaftEnd.next = reverse(firstHalfEnd.next);
        return result;
    }

    public static ListNode reverse(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        return prev;
    }

    public static ListNode endOfFirstList(ListNode head) {
        //设置快慢指针进行查找
        ListNode fast = head;
        ListNode slow = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

二、环形链表

2.1 题目描述

2.2 思路分析

2.3 代码演示

public boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        ListNode fast = head.next;
        ListNode slow = head;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            //fast指针每次比slow指针快走两步
            //若该链表存在环，则这两个指针会进入环中
            //fast总有机会比slow多转n圈从而追上slow
            //此时跳出循环，表示该链表是环形来链表
            fast = fast.next.next;
            slow = slow.next;
        }
        return true;
    }

三、合并两个有序链表

3.1 题目描述

3.2 思路分析

3.3 代码演示

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null && list2 == null) {
            return null;
        }
        if(list1 == null && list2 != null) {
            return list2;
        }
        if(list1 != null && list2 == null) {
            return list1;
        }
        //定义一个哨兵位节点
        ListNode preHead = new ListNode(-1);
        //定义一个指针指向哨兵位，作为遍历指针
        ListNode prev = preHead;
        //当链表都不为空时，开始遍历
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {     //遍历链表，比较链表当前节点的值的大小
                prev.next = list1;          //若链表1的值小，则将哨兵位的下一个节点指向链表1
                list1 = list1.next;         //链表1继续遍历
            } else {
                prev.next = list2;          //若链表2的值小，则将哨兵位的下一个节点指向链表2
                list2 = list2.next;         //链表2继续遍历
            }
            prev = prev.next;               //prev继续遍历链表
        }
        prev.next = list1 == null ? list2 : list1;  //若链表长度不等，则较长的链表直接将剩余的节点加到prev的next下即可
        return preHead.next;                        //返回合并后的链表的头节点，即哨兵位的下一个节点
    }