算法学习篇——链表篇2

题目：给定一个有环链表，实现一个算法返回环路的开头结点。有环链表的定义:在链表中某个结点的next元素指向在它前面出现过的节点，则表明该链表存在环路

思路一：使用hashset去重，把出现过的节点依次放入hashset，如果重复，则输出。

思路二：

• 利用快慢指针(也称为弗洛伊德循环检测算法)，一个步长为1，一个步长为2。若有环链表，两者必定在某一点相遇。当快慢指针相遇时，将其中一个指针重新指向链表头，然后两个指针都以步长为1移动，再次相遇的点即为环的起点。
• 假设p1移动速度为v，p2移动速度为2v。当p1第一次进入环形链表时，p2移动的步长为p1的两倍，假设p1移动的步长为k，p2与p1相距为$k$。因为p1和p2方向相同，假设环的长度为$L$，p2实际要追赶上p1的距离为$L-k$。追赶上的时间为距离除以速度之差$t=\frac{L-k}{2v-v}=\frac{L-k}{v}$，可得$L-k=t\ast v$。其中t*v为p1走过的距离等于$L-k$。从下图可看出，一开始p1到环形链表与p1=p2时离环形链表头的距离都为k。根据这个条件可获得当时节点的值。
• 此算法没有使用额外的空间，切时间复杂度为$O(n)$级别。
  

    public static void main(String[] args) {
        // 创建一个包含20个节点的有环链表
        ListIntNode head = createCircularLinkedList(10);
        System.out.println("head= "+head);
        // 解法一：hashset去重
        HashSet<ListIntNode> hashSet = new HashSet<>();
        ListIntNode p = head;
        while (p != null){
            if (hashSet.contains(p)){
                System.out.println("使用hashSet得出循环的节点是：" + p.value);
                break;
            }
            hashSet.add(p);
            p = p.next;
        }
        // 解法二：利用快慢步长，一个步长为1，一个步长为2。若有环链表，两者必定在某一点相遇。
        ListIntNode p1 = head;
        ListIntNode p2 = head;
        boolean hasCycle = false;
        while (p2 != null && p2.next != null) {
            p1 = p1.next;
            p2 = p2.next.next;
            if (p1 == p2) {
                hasCycle = true;
                break;
            }
        }
        if (hasCycle) {
            // 找到环的起点
            // 当快慢指针相遇时，将其中一个指针重新指向链表头，然后两个指针都以步长为1移动，再次相遇的点即为环的起点
            p1 = head;
            while (p1 != p2) {
                p1 = p1.next;
                p2 = p2.next;
            }
            System.out.println("使用快慢步长得出的循环节点是：" + p1.value);
        } else {
            System.out.println("没有循环链表");
        }
    }


    private static ListIntNode createCircularLinkedList(int size) {
        if (size <= 0) {
            return null;
        }

        Random random = new Random();
        ListIntNode head = new ListIntNode(random.nextInt(100) + 1);
        ListIntNode current = head;

        // 创建size个节点
        for (int i = 1; i < size; i++) {
            current.next = new ListIntNode(random.nextInt(100) + 1);
            current = current.next;
        }

        // 形成环，将最后一个节点指向第5个节点（索引为4）
        ListIntNode loopStart = head;
        for (int i = 0; i < 4; i++) {
            loopStart = loopStart.next;
        }
        current.next = loopStart;

        return head;
    }

    public static class ListIntNode{
        int value;
        ListIntNode next;

        public ListIntNode(int value) {
            this.value = value;
        }

        @Override
        public String toString(){
            StringBuilder sb = new StringBuilder("[");
            ListIntNode nextNode = this;
            // 跳过哑元节点
            if (this.value == 0 && this.next != null) {
                nextNode = this.next;
            }
            int count = 0; // 防止无限循环
            while (nextNode != null && count < 100) {
                // 拼接下一个节点的值，哑元值不打印
                sb.append(nextNode.value);
                sb.append(",");
                nextNode = nextNode.next;
                count++;
            }
            if (sb.length() > 1) {
                // 移除最后一个逗号
                sb.setLength(sb.length() - 1);
            }
            sb.append("]");
            return sb.toString();
        }
    }

运行结果如图

题目：判断链表是否为回文链表

思路一：用快慢指针计算出中间节点。创建一个栈用于压入前半部分链表的值，然后把慢指针中间后面的值与栈弹出的值依次对比，全部相等表示是回文链表。
时间复杂度：$O(n)$，n 是链表的节点个数。
空间复杂度：$O(n/2)\approx O(n)$，使用了栈来保存前一半节点的值。
思路一：用快慢指针计算出中间节点。从slow开始反转后半部分链表，把反转后的链表与原链表比较，值依次对比直到反转的链表后一个节点为空时，若此期间值全部相等表示是回文链表。
时间复杂度：$O(n)$ —— 遍历链表最多两次（找中间点、比较、恢复链表）。
空间复杂度：$O(1)$—— 只用了几个指针变量，没有使用额外的数据结构。

import java.util.Stack;

class ListNode {
    int val;
    ListNode next;

    // 构造方法
    ListNode(int val) {
        this.val = val;
    }

    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder("[");
        ListNode nextNode = this;
        // 跳过哑元节点
        if (this.val == 0 && this.next != null) {
            nextNode = this.next;
        }
        int count = 0; // 防止无限循环
        while (nextNode != null && count < 100) {
            // 拼接下一个节点的值，哑元值不打印
            sb.append(nextNode.val);
            sb.append(",");
            nextNode = nextNode.next;
            count++;
        }
        if (sb.length() > 1) {
            // 移除最后一个逗号
            sb.setLength(sb.length() - 1);
        }
        sb.append("]");
        return sb.toString();
    }
}

public class PalindromeLinkedList {

    // 主函数：判断链表是否为回文链表
    public boolean isPalindromeByStack(ListNode head) {
        // 边界情况：如果链表为空或只有一个节点，认为是回文链表
        if (head == null || head.next == null) {
            return true;
        }

        System.out.println("head: "+ head);
        // 使用快慢指针找到链表的中间节点
        ListNode slow = head;
        ListNode fast = head;

        // 创建一个栈用于存储前半部分链表的值
        Stack<Integer> stack = new Stack<>();

        // 快指针走两步，慢指针走一步，当快指针到末尾时，慢指针刚好在中间
        while (fast != null && fast.next != null) {
            stack.push(slow.val); // 将前半部分节点的值压入栈中
            slow = slow.next;
            fast = fast.next.next;
        }
        System.out.println("slow: "+slow);
        System.out.println("fast: "+fast);
        System.out.println("stack: "+stack);

        // 如果链表长度为奇数，快指针最后会停在非null的位置，此时慢指针指向中间节点
        // 此时需要将慢指针向后移动一位，跳过中间节点（因为中间节点不影响回文）
        if (fast != null) {
            slow = slow.next;
            System.out.println("slow-next: "+slow);
        }
        // 从慢指针开始遍历后半部分链表，并与栈中弹出的值进行比较
        while (slow != null) {
            // 如果当前节点的值不等于栈中弹出的值，则不是回文链表
            if (slow.val != stack.pop()) {
                return false;
            }
            slow = slow.next;
        }

        // 所有对应值都相等，是回文链表
        return true;
    }

    public boolean isPalindromeBySlowFast(ListNode head) {
        if (head == null || head.next == null) {
            return true; // 空链表或只有一个节点，视为回文
        }

        // 第一步：使用快慢指针找到中间节点
        ListNode slow = head;
        ListNode fast = head;

        System.out.println("head: "+ head);
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        System.out.println("slow: "+slow);
        System.out.println("fast: "+fast);
        // 第二步：从slow开始反转后半部分链表
        ListNode prev = null;
        ListNode curr = slow;
        while (curr != null) {
            ListNode nextTemp = curr.next; // 保存下一个节点
            curr.next = prev;              // 当前节点指向前一个节点
            prev = curr;                   // 移动prev
            curr = nextTemp;               // 移动curr
        }
        System.out.println("prev: "+prev);
        // 第三步：比较前半部分和反转后的后半部分
        ListNode firstHalf = head;
        ListNode secondHalf = prev; // 反转后的头节点

        boolean result = true;
        while (secondHalf != null) {
            if (firstHalf.val != secondHalf.val) {
                result = false;
                break;
            }
            firstHalf = firstHalf.next;
            secondHalf = secondHalf.next;
        }

        // 第四步：（可选）还原链表（如果你不希望修改原始链表）
        reverseList(slow);

        return result;
    }

    // 辅助函数：反转链表
    private void reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
    }

    // 测试示例
    public static void main(String[] args) {
        // 创建测试链表：1 -> 2 -> 2 -> 1
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(2);
        head.next.next.next.next = new ListNode(1);

        PalindromeLinkedList solution = new PalindromeLinkedList();

        // 调用判断函数
        boolean result = solution.isPalindromeByStack(head);
        // 输出结果
        System.out.println("该链表是否为回文链表：" + (result ? "是" : "否"));

        boolean result1 = solution.isPalindromeBySlowFast(head);
        // 输出结果
        System.out.println("该链表是否为回文链表：" + (result1 ? "是" : "否"));
    }
}

运行结果如图