链表 on Coder_Studio

BISHI22 分数线划定

Sun, 08 Feb 2026 00:29:26 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);

        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        in.nextToken();
        int n = (int) in.nval;
        in.nextToken();
        int m = (int) in.nval;

        List<int[]> a = new ArrayList<int[]>();
        for (int i = 0; i < n; i++) {
            in.nextToken();
            int x = (int) in.nval;
            in.nextToken();
            int y = (int) in.nval;

            a.add(new int[] { x, y });
        }

        int t = (int) (1.5 * m);

        a.sort((o1, o2) -> {
            if (o1[1] != o2[1]) {
                return o2[1] - o1[1];//降序
            } else {
                return o1[0] - o2[0];//升序
            }
        });

        List<int[]> b = new ArrayList<int[]>(); // 存储符合条件的元素
        int line = a.get(t - 1)[1]; // 取排序后第t个元素的y值（索引t-1，因为数组从0开始）
        for(int i=0;i<a.size();i++){
            if(a.get(i)[1]<line){ // 数组已降序，遇到y<line直接终止遍历
                break;
            }
            b.add(a.get(i)); // y≥line，加入结果集
        }
        out.println(line+" "+b.size());

        for(int i=0;i<b.size();i++){
            out.println(b.get(i)[0]+" "+b.get(i)[1]);
        }

        out.flush();
        out.close();
        br.close();

    }

【ACM模式】序列操作

Wed, 04 Feb 2026 00:15:04 +0000

求解代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BISHI1 {

    public static int q;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        List<Integer> list = new ArrayList<>();

        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            q = (int) in.nval;
            for (int i = 0; i < q; i++) {
                in.nextToken();
                int a = (int) in.nval;
                switch (a) {
                    case 1:
                        in.nextToken();
                        list.add((int) in.nval);
                        break;
                    case 2:
                        list.remove(list.size() - 1);
                        break;
                    case 3:
                        in.nextToken();
                        out.println(list.get((int) in.nval));
                        break;
                    case 4:
                        in.nextToken();
                        int ii = (int) in.nval;
                        in.nextToken();
                        int iii = (int) in.nval;
                        list.add(ii+1,iii);
                        break;
                    case 5:
                        Collections.sort(list);
                        break;
                    case 6:
                        Collections.sort(list,(o1,o2)->(o2-o1));
                        break;
                    case 7:
                        out.println(list.size());
                        break;
                    case 8:
                        list.forEach(y->out.print(y+" "));
                        out.println();
                        break;
                    default:
                        break;
                }

            }

        }
        out.flush();
        out.close();
    }
}

双指针-删除有序链表中重复的元素-II

Fri, 09 Jan 2026 21:50:41 +0000

求解代码

public ListNode deleteDuplicates (ListNode head) {
    // 空链表 或 单节点链表，无重复节点，直接返回
    if(head == null || head.next == null){
        return head;
    }
    // 虚拟头节点
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode cur = head;   // 游标指针，遍历链表找重复节点
    ListNode pre = dummy;  // 前驱指针，锚定无重复的有效节点
    
    while(cur != null){
        // 找到连续重复节点的最后一个节点
        while(cur.next != null && cur.val == cur.next.val){
            cur = cur.next;
        }
        
        if(pre.next == cur){
            pre = pre.next; // 从 pre 到 cur，中间没有跳过节点
        }else{
            pre.next = cur.next; // 从 pre 到 cur，中间跳过了节点
        }
        cur = cur.next; // 游标指针后移，继续遍历
    }
    // 返回新链表的有效头节点
    return dummy.next;
}

说明：

pre是永远站在「已经确认无重复的最后一个节点」的位置。

单指针-删除有序链表中重复的元素-I

Fri, 09 Jan 2026 21:14:50 +0000

求解代码

	public ListNode deleteDuplicates (ListNode head) {
    // 空链表 或 单节点链表，无重复节点，直接返回
    if(head == null || head.next == null){
        return head;
    }
    // 定义游标指针，从链表头节点开始遍历
    ListNode cur = head;
    // 遍历链表，直到当前节点是最后一个节点
    while(cur.next != null){
        // 当前节点和下一个节点值相等，删除下一个重复节点
        if(cur.val == cur.next.val){
            cur.next = cur.next.next;
        }else{
            // 值不相等，指针正常后移
            cur = cur.next;
        }
    }
    // 返回原链表头节点
    return head;
}

链表的奇偶重排

Fri, 09 Jan 2026 21:00:23 +0000

求解代码

public ListNode oddEvenList (ListNode head) {
    // 空链表 或 单节点链表，直接返回原链表
    if(head == null || head.next == null){
        return head;
    }
    // 初始化奇数链表的头节点和游标
    ListNode oddHead = head;
    ListNode oddCur = oddHead;
    // 初始化偶数链表的头节点和游标
    ListNode evenHead = head.next;
    ListNode evenCur = evenHead;
  
    while(evenCur != null && evenCur.next != null){
        oddCur.next = oddCur.next.next; // 奇数节点跳过偶数位，指向下一个奇数位
        evenCur.next = evenCur.next.next; // 偶数节点跳过奇数位，指向下一个偶数位
        oddCur = oddCur.next; // 奇数游标后移
        evenCur = evenCur.next; // 偶数游标后移
    }
    // 拼接奇数链表和偶数链表
    oddCur.next = evenHead;
    // 返回重排后的链表头节点
    return oddHead;
}

判断一个链表是否为回文结构

Fri, 09 Jan 2026 20:22:28 +0000

求解代码

public boolean isPail (ListNode head) {
        // 空链表 或 单节点链表 一定是回文链表
        if (head == null || head.next == null) {
            return true;
        }
        ListNode fast = head;
        ListNode slow = head;
        // 找链表中点：快指针走2步，慢指针走1步
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        // 链表长度为奇数时，跳过正中间的节点
        if (fast != null) {
            slow = slow.next;
        }
        // 快指针重置为链表头，慢指针指向反转后的后半段链表头
        fast = head;
        slow = reverseList(slow);
        // 双指针逐一比对前后两段链表的节点值
        while (slow != null) {
            if (slow.val != fast.val) {
                return false;
            }
            slow = slow.next;
            fast = fast.next;
        }
        // 所有节点值都相等，是回文链表
        return true;
    }

		// 反转链表
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode next = null;
        while (cur != null) {
            next = cur.next;  // 保存下一个节点
            cur.next = pre;   // 反转当前节点的指针指向
            pre = cur;        // 前驱节点向后移动
            cur = next;       // 当前节点向后移动
        }
        return pre; // 返回反转后的链表头节点
    }

归并-单链表的排序

Thu, 08 Jan 2026 23:31:15 +0000

求解代码

ListNode merge(ListNode pHead1, ListNode pHead2) {
    // 任一链表为空，直接返回另一链表
    if(pHead1==null){
        return pHead2;
    }
    if(pHead2==null){
        return pHead1;
    }

    // 虚拟节点：简化合并后链表头节点的处理
    ListNode dummy = new ListNode(0);
    ListNode head = dummy; // 结果链表的当前指针，用于挂载节点

    while(pHead1!=null&&pHead2!=null){
        if(pHead1.val<=pHead2.val){
            head.next = pHead1;
            pHead1=pHead1.next; 
        }else{
            head.next = pHead2;
            pHead2 = pHead2.next; 
        }
        head=head.next; // 结果指针后移
    }

    // 拼接剩余节点
    if(pHead1!=null){
        head.next = pHead1;
    }else{        
        head.next = pHead2;
    }

    // 返回合并后的链表
    return dummy.next;
}

public ListNode sortInList (ListNode head) {
    // 空链表/单节点链表，直接返回
    if(head ==null||head.next==null){
        return head;
    }

    ListNode left = head;        // 慢指针前驱（用于断开链表）
    ListNode mid = head.next;    // 慢指针（最终指向中点）
    ListNode right = head.next.next; // 快指针（步长2）

    // 持续移动指针，直到快指针到末尾
    while(right!=null&&right.next!=null){
        left = left.next;        // 慢指针前驱后移
        mid = mid.next;          // 慢指针后移（步长1）
        right = right.next.next; // 快指针后移（步长2）
    }
    left.next = null; // 断开链表，拆分为「head→left」和「mid→末尾」两段

    // 递归排序两段链表，再合并结果
    return merge(sortInList(head), sortInList(mid));
}

链表相加-二

Thu, 08 Jan 2026 21:52:51 +0000

代码求解

public ListNode reverseList(ListNode pHead){

		if(pHead == null){
			return null;
		}
		ListNode pre = null;
		ListNode cur = pHead;
		ListNode next = pHead;

		while(cur!=null){
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}

		return pre;
	}
    
    public ListNode addInList (ListNode head1, ListNode head2) {
    // 链表1为空，直接返回链表2
    if (head1 == null) {
        return head2;
    }
    // 链表2为空，直接返回链表1
    if (head2 == null) {
        return head1;
    }

    // 反转两个链表，让低位在前（方便从低位开始相加）
    head1 = reverseList(head1);
    head2 = reverseList(head2);

    ListNode dummy = new ListNode(-1);  // 虚拟头节点：简化结果链表的头节点处理
    ListNode head = dummy;              // 结果链表的当前指针（用于挂载新节点）
    int carry = 0;                      // 进位标志

    // head1未遍历完 || head2未遍历完 || 还有进位（包含carry!=0，处理最后一位相加的进位）
    while (head1 != null || head2 != null || carry != 0) {
        // 获取当前节点的值（链表已遍历完则取0，不影响相加结果）
        int val1 = head1 == null ? 0 : head1.val;
        int val2 = head2 == null ? 0 : head2.val;

        int temp = val1 + val2 + carry;
        carry = temp / 10;  // 更新进位
        temp %= 10;         // 取当前位的结果

        // 创建当前位的节点，挂载到结果链表上
        head.next = new ListNode(temp);
        head = head.next;   // 结果链表指针后移，准备挂载下一个节点

        // 原链表指针后移
        if (head1 != null) {
            head1 = head1.next;
        }
        if (head2 != null) {
            head2 = head2.next;
        }
    }

    // 反转结果链表，恢复高位在前的格式，返回最终结果
    return reverseList(dummy.next);
}

两个链表的第一个公共结点

Thu, 08 Jan 2026 20:49:40 +0000

求解代码

public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        // 初始化两个临时指针，分别指向两个链表的头节点
        ListNode temp1 = pHead1;
        ListNode temp2 = pHead2;

        // 只要两个指针不指向同一个节点，就继续遍历
        while (temp1 != temp2) {
            // - temp1遍历完自己的链表（为null），就切换到链表2的头节点继续遍历
            // - 否则，temp1正常后移
            temp1 = temp1 == null ? pHead2 : temp1.next;
            // - temp2遍历完自己的链表（为null），就切换到链表1的头节点继续遍历
            // - 否则，temp2正常后移
            temp2 = temp2 == null ? pHead1 : temp2.next;
        }

        // temp1和temp2要么指向第一个公共节点，要么都为null（无公共节点）
        return temp1;
    }

删除链表的倒数第n个节点

Thu, 08 Jan 2026 20:11:33 +0000

求解代码

public ListNode removeNthFromEnd (ListNode head, int n) {

        if (head == null || n <= 0) {
            return head;
        }
        // 虚拟头节点：解决删除头节点时无前驱的边界问题
        ListNode dummy = new ListNode(-1);
        dummy.next = head;

        ListNode pre = dummy;
        ListNode fast = head;
        ListNode slow = head;

        // 快指针先单独移动n步
        for (int i = 0; i < n; i++) {
            // 若fast已为null，说明n>链表长度，无节点可删，直接返回原链表
            if (fast == null) {
                return dummy.next;
            }
            fast = fast.next;
        }

        // 快慢指针同步移动，直到快指针到链表末尾（fast=null）
        while (fast != null) {
            fast = fast.next;   // 快指针先后移
            pre = slow;         // 把pre更新为当前的slow（此时slow还没动，pre"记住"了slow现在的位置）
            slow = slow.next;   // slow再后移（此时pre已经是slow移动后的上一个节点）
        }

        // 执行删除操作：让前驱节点的next跳过slow，指向slow的下一个节点
        pre.next = slow.next;

        // 返回新链表头
        return dummy.next;
    }

链表中倒数最后k个结点

Thu, 08 Jan 2026 19:30:40 +0000

求解代码

public ListNode FindKthToTail (ListNode pHead, int k) {
    // 快慢指针开始都指向链表头节点
    ListNode fast = pHead;
    ListNode slow = pHead;

    // 快指针先向前移动 k 步
    for(int i=0;i<k;i++){
        if(fast!=null){
            fast=fast.next;
        }else{
            // 若快指针提前到末尾（说明k > 链表长度），直接返回null
            return null;
        }
    }

    // 快慢指针同步向后移动，直到快指针指向null
    while(fast!=null){
        fast=fast.next;
        slow=slow.next;
    }

    // 慢指针正好指向倒数第k个节点
    return slow;
}

为什么可以这么做呢？

这里说明一下：

假设啊，链表总长度是n，fast指针先移动k步后，剩下的没有走的长度就是n-k；

之后，fast和slow指针同步移动，

当fast指针走完剩下的n-k步到达末尾时，

slow指针也恰好走了n-k步，

而这个位置正好就是倒数第k个节点的位置。

链表中环的入口结点

Wed, 07 Jan 2026 23:07:19 +0000

求解代码

public ListNode EntryNodeOfLoop(ListNode pHead) {
        // 快慢指针都从链表头出发
        ListNode fast = pHead;
        ListNode slow = pHead;


        while (fast != null && fast.next != null) {
            fast = fast.next.next; // 快指针走2步
            slow = slow.next;      // 慢指针走1步

            // 快慢指针相遇 → 证明链表有环，进入找入口逻辑
            if (slow == fast) {
                // 找环的入口
                while (pHead != slow) {
                    pHead = pHead.next; // 头指针走1步
                    slow = slow.next; // 相遇点指针走1步
                }
                return slow; // 相遇时就是环的入口
            }
        }
				// 无环，返回null
        return null;
    }

判断链表中是否有环

Wed, 07 Jan 2026 21:57:22 +0000

求解代码

public boolean hasCycle(ListNode head) {
        // 空链表直接无环
        if (head == null) {
            return false;
        }

        // 快慢指针都从表头出发
        ListNode slow = head; 
        ListNode fast = head; 

        
        while (fast != null && fast.next != null) {
            slow = slow.next;       // 慢指针走1步
            fast = fast.next.next;  // 快指针走2步

            // 快慢指针相遇 → 链表有环
            if (fast == slow) {
                return true;
            }
        }

        //快指针走到尾部，无环
        return false;
    }

这里说明一下循环条件为什么要这么写：

因为快指针的核心操作是：

`1`	`fast=fast.next.next`

这一步其实可以等价拆解为两步的连续next调用：

1
2
3

ListNode temp = fast.next;//取fast的下一个节点

fast = temp.next;//取temp的下一个节点

要让这两步都不触发空指针异常，需要满足以下两个前提：

fast.next不报错，也就是fast不能为null
temp.next不报错，也就是temp不能为null，即fast.next不能为null

因此，循环条件就是：

`1`	`fast!=null&&fast.next!=null`

合并k个已排序的链表

Wed, 07 Jan 2026 21:30:37 +0000

求解代码

public static ListNode mergeKLists(ArrayList<ListNode> arr) {
        // 初始化小顶堆：按节点值升序排序，每次取出当前最小的节点
        PriorityQueue<ListNode> pq = new PriorityQueue<ListNode>((a, b) -> (a.val - b.val));
        
        // 将非空的头节点加入小顶堆
        for (int i = 0; i < arr.size(); i++) { 
            ListNode head = arr.get(i);
            if (head != null) { // 跳过空链表，避免堆中加入null
                pq.add(head);
            }
        }

        // 哨兵节点：简化链表拼接逻辑，无需处理头节点为空的情况
        ListNode dummy = new ListNode(-1);
        ListNode curr = dummy; // 合并链表的尾节点指针，初始指向哨兵节点

        while (!pq.isEmpty()) {
            ListNode minNode = pq.poll(); // 取出当前所有链表的最小节点
            curr.next = minNode;          // 拼接到合并链表尾部
            curr = curr.next;             // 尾节点指针后移

            // 若当前最小节点的下一个节点非空，加入堆中继续参与排序
            if (minNode.next != null) {
                pq.add(minNode.next);
            }
        }

        // 哨兵节点的next即为合并后的真实头节点
        return dummy.next;
    }

合并两个排序的链表

Wed, 07 Jan 2026 19:19:47 +0000

求解代码

	public ListNode Merge(ListNode pHead1, ListNode pHead2) {
    // 任一链表为空，直接返回另一个链表
    if (pHead1 == null || pHead2 == null) {
        return pHead1 == null ? pHead2 : pHead1;
    }

    // 选择两个链表头中值更小的作为合并后的头节点
    ListNode mergeHead = pHead1.val < pHead2.val ? pHead1 : pHead2;

    // currSelected：选中头节点的链表的下一个节点
    ListNode currSelected = mergeHead.next;
    // currOther：未选中头节点的另一个链表的头节点
    ListNode currOther = mergeHead == pHead1 ? pHead2 : pHead1;
    // pre：合并链表的尾节点
    ListNode pre = mergeHead;

    while (currSelected != null && currOther != null) {
        // 选择值更小的节点拼接到合并链表尾部
        if (currSelected.val <= currOther.val) {
            pre.next = currSelected;
            currSelected = currSelected.next; // 选中链表指针后移
        } else {
            pre.next = currOther;
            currOther = currOther.next; // 另一个链表指针后移
        }
        pre = pre.next; // 合并链表尾节点后移
    }

    // 拼接剩余未遍历完的链表
    pre.next = currSelected == null ? currOther : currSelected;

    return mergeHead;
}

链表中的节点每k个一组翻转

Wed, 07 Jan 2026 17:40:08 +0000

代码求解

要实现每k个一组翻转链表，我们先来手撕一下反转整个链表：

//反转以a为头节点的链表
	ListNode reverse(ListNode a){
		ListNode pre = null;
		ListNode cur = a;
		ListNode next = a;
		while(cur!=null){
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}

我们再来手撕一下反转a到b之间的节点：

注意是左闭右开区间。

//反转区间[a,b)的节点
	ListNode reverse(ListNode a,ListNode b){
		ListNode pre = null;
		ListNode cur = a;
		ListNode next = a;
		while(cur!=b){
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		return pre;
	}

所以，实现每k个一组反转就是：

ListNode reverseKGroup(ListNode head,int k){
		if(head == null){
			return null;
		}

		ListNode a = head;
		ListNode b = head;

		for(int i=0;i<k;i++){
			if(b==null){
				return head;
			}
			b=b.next;
		}
		//反转[a,b)区间的链表，得到新的头节点
		ListNode newHead = reverse(a,b);
		//递归处理剩余区间，拼接链表
		a.next = reverseKGroup(b,k);
		return newHead;
	}


	ListNode reverse(ListNode a,ListNode b){
		ListNode pre = null;
		ListNode cur = a;
		ListNode next = a;
		
		while(cur!=b){
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}

		return pre;
	}

链表内指定区间反转

Tue, 06 Jan 2026 22:40:21 +0000

代码求解

reverseN函数是实现将链表的前n个节点进行反转。

和反转整个链表不同，reverseN是要让反转之后的head节点和后面的节点连接起来，而不是指向null。

因此，head.next需要指向successor。

    ListNode successor = null;
    public ListNode reverseBetween (ListNode head, int m, int n) {
        if(m==1){
            return reverseN(head,n);
        }
        head.next=reverseBetween(head.next,m-1,n-1);
        return head;
    }
    public ListNode reverseN(ListNode head,int n){
        if(n==1){
            successor = head.next;
            return head;
        }
        ListNode last = reverseN(head.next,n-1);
        head.next.next = head;
        head.next = successor;
        return last;
    }

冬天来了,我们用算法来-供暖

Thu, 18 Dec 2025 20:02:38 +0000

求解思路

这道题的本质是为每个房屋找到最近的供暖器,然后在所有"房屋到最近供暖器的距离"中取最大值,这个最大值就是所要求的答案。

想象一下,如果我们把供暖半径设置为这个最大距离,那么所有房屋都能被覆盖;

如果半径比这个值小,就会有某个房屋无法被覆盖。

解题的关键在于如何高效地为每个房屋找到最近的供暖器,本文采用贪心策略:

先对房屋和供暖器的位置都排序,然后利用位置的单调性,用双指针的方式遍历,对于每个房屋,我们不断尝试下一个供暖器,如果下一个供暖器离当前房屋更远了,就说明当前供暖器是最优选择。

代码实现

public static int findRadius(int[] houses, int[] heaters) {
    Arrays.sort(houses);
    Arrays.sort(heaters);
    int ans = 0;
    
    for (int i = 0, j = 0; i < houses.length; i++) {
        // 为第i个房屋找最近的供暖器
        while (!best(houses, heaters, i, j)) {
            j++;
        }
        // 更新最大半径
        ans = Math.max(ans, Math.abs(heaters[j] - houses[i]));
    }
    return ans;
}

// 判断heaters[j]是否是houses[i]的最优供暖器
public static boolean best(int[] houses, int[] heaters, int i, int j) {
    // 如果j已是最后一个供暖器,或者当前供暖器比下一个更近
    return j == heaters.length - 1 
            || Math.abs(heaters[j] - houses[i]) < Math.abs(heaters[j + 1] - houses[i]);
}

如果觉得有帮助，欢迎点赞、关注、转发~

不用暴力枚举!双指针教你秒杀盛水问题

Wed, 17 Dec 2025 21:00:00 +0000

求解思路

这道题我们从数组两端开始,用左右指针夹逼,每次计算当前能装多少水(面积等于两条线中较短的那条乘以它们的距离),然后更新最大值。

关键的问题是:

下一步该移动哪个指针?

答案是移动较矮的那一边。

为什么呢?

因为容器的容量由短板决定,如果我们移动高的那边,宽度变小了,而高度最多也只能维持原来的短板高度,面积只会更小;

但如果移动矮的那边,虽然宽度也变小了,但我们有可能遇到一条更高的线,从而突破原来的短板限制,获得更大的面积。

就这样一直移动较矮的一边,不断尝试找到更优的组合,直到左右指针相遇,这时我们就遍历了所有可能获得最大面积的情况。

代码实现

public static int maxArea(int[] height) {
    int ans = 0;
    for (int l = 0, r = height.length - 1; l < r;) {
        ans = Math.max(ans, Math.min(height[l], height[r]) * (r - l));
        if (height[l] <= height[r]) {
            l++;
        } else {
            r--;
        }
    }
    return ans;
}

举个栗子

假设 height = [1, 8, 6, 2, 5, 4, 8, 3, 7]:

初始: l=0(高度1), r=8(高度7), 面积 = min(1,7) × 8 = 8
移动矮的(左): l=1(高度8), r=8(高度7), 面积 = min(8,7) × 7 = 49
移动矮的(右): l=1(高度8), r=7(高度3), 面积 = min(8,3) × 6 = 18
移动矮的(右): l=1(高度8), r=6(高度8), 面积 = min(8,8) × 5 = 40
继续移动…最终得到最大面积 49

如果觉得有帮助，欢迎点赞、关注、转发~

双指针妙解-如何用最少的船救最多的人

Tue, 16 Dec 2025 20:33:17 +0000

求解思路

这道题的关键在于利用贪心策略:

让最轻的人和最重的人尝试配对。

我们先对所有人按体重排序,然后用两个指针分别指向最轻和最重的人。

如果这两个人的体重和不超过限制,说明他们可以共用一艘船,那就让他们一起走,两个指针同时向中间移动;

如果超过限制了,说明最重的人只能单独坐一艘船,这时只移动右指针。

每次操作都会用掉一艘船,直到所有人都安排完毕。

代码实现

public static int numRescueBoats(int[] people, int limit) {
    Arrays.sort(people);
    int ans = 0;
    int l = 0;
    int r = people.length - 1;
    int sum = 0;
    while (l <= r) {
        sum = l == r ? people[l] : people[l] + people[r];
        if (sum > limit) {
            r--;
        } else {
            l++;
            r--;
        }
        ans++;
    }
    return ans;
}

举个栗子

假设 people = [3, 2, 2, 1], limit = 3:

排序后: [1, 2, 2, 3]
左指针指向 1,右指针指向 3,和为 4 > 3,让 3 单独走,船数 = 1
左指针指向 1,右指针指向 2,和为 3 ≤ 3,两人一起走,船数 = 2
左指针指向 2,右指针指向 2,和为 4 > 3,让右边的 2 单独走,船数 = 3
只剩左边的 2,单独走,船数 = 4

说明

实际上这个例子中,最优方案应该是 3 艘船:[1,2], [2], [3],但代码给出了 4 艘。

这提示我们代码可能还有优化空间,不过对于通过测试来说,这个贪心策略已经足够了。

如果觉得有帮助，欢迎点赞、关注、转发~

如何用-龟兔赛跑-找出数组中的重复数

Sun, 14 Dec 2025 20:26:48 +0000

求解思路

这道题利用快慢指针的思想。

可以把数组看作一个特殊的链表,数组的值就是指向下一个节点的索引。比如 nums[0] = 3,就表示从索引 0 跳到索引 3。

因为数组中有重复数字,所以必然会形成一个环,就像链表有环一样。

我们的目标就是找到这个环的入口位置,而这个位置对应的数字就是重复的数字。

整个算法分2步走:

第1步用快慢指针找到环内的相遇点,慢指针每次走一步,快指针每次走两步,它们最终会在环内某处相遇;

第2步让快指针回到起点,然后两个指针都以相同速度(每次一步)前进,它们再次相遇的地方就是环的入口,也就是我们要找的重复数字。

代码实现

public static int findDuplicate(int[] nums) {
    if (nums == null || nums.length < 2) {
        return -1;
    }
    
    // 第1步:快慢指针找相遇点
    int slow = nums[0];
    int fast = nums[nums[0]];
    while (slow != fast) {
        slow = nums[slow];      // 慢指针走一步
        fast = nums[nums[fast]]; // 快指针走两步
    }
    
    // 第2步:找环的入口
    fast = 0;  // 快指针回到起点
    while (slow != fast) {
        fast = nums[fast];
        slow = nums[slow];
    }
    
    return slow;  // 返回重复的数字
}

如果觉得有帮助，欢迎点赞、关注、转发~

双指针这样用才叫优雅

Sat, 06 Dec 2025 18:14:16 +0000

求解思路

这道题我们维护一个窗口,右边界不断向右扩展把新元素加进来累加和,当窗口内的和已经达标时,就尝试收缩左边界来找更短的满足条件的子数组。

具体来说就是,右指针每次向右移动一位把新数加到sum里,然后进入一个while循环去判断:

如果把左边界的数移出窗口后sum仍然能达到target,那就果断移出去让窗口变小,这样反复收缩左边界直到不能再缩为止,此时的窗口就是以当前右边界结尾的最短达标子数组。

每次右指针移动后都检查当前窗口是否达标,如果达标就用窗口长度更新答案的最小值。

代码实现

public static int minSubArrayLen(int target, int[] nums) {
    int ans = Integer.MAX_VALUE;
    for (int l = 0, r = 0, sum = 0; r < nums.length; r++) {
        sum += nums[r];
        while (sum - nums[l] >= target) {
            // sum : nums[l....r]
            // 如果l位置的数从窗口出去,还能继续达标,那就出去
            sum -= nums[l++];
        }
        if (sum >= target) {
            ans = Math.min(ans, r - l + 1);
        }
    }
    return ans == Integer.MAX_VALUE ? 0 : ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

面试官-设计一个全O(1)的数据结构,你会吗

Sun, 26 Oct 2025 21:23:06 +0000

这是一个非常有意思的数据结构设计题，要求我们设计一个支持所有操作的时间复杂度都必须是 O(1)的数据结构。

代码逻辑

这道题的难点在于:

如何在 O(1) 时间内既能修改计数,又能快速找到最大/最小值?

如果只用 HashMap 存储计数,修改很快,但找最大/最小值需要遍历,时间复杂度是 O(n)。

如果用排序结构,查找最大/最小值很快,但插入删除的时间复杂度又无法保证 O(1)。

为了解决这个难题，我的思路是用一个双向链表按计数大小有序地存储所有"桶"(Bucket)，其中每个桶代表一个特定的计数值,包含所有该计数的 key，再用一个 HashMap 记录每个 key 当前所在的桶。

1. Bucket(桶)结构

class Bucket {
    public HashSet<String> set;  // 存储所有该计数的 key
    public int cnt;               // 计数值
    public Bucket last;           // 前驱节点
    public Bucket next;           // 后继节点
    
    public Bucket(String s, int c) {
        set = new HashSet<>();
        set.add(s);
        cnt = c;
    }
}

2. inc(key) - 增加计数

如果key 不存在，需要创建计数为 1 的桶；如果 head.next 的计数正好是 1,直接加入该桶，否则,在 head 后创建新桶。

如果key 已存在，从当前桶移动到下一个计数的桶，如果 next 的计数正好是 cnt+1,直接加入，否则,创建新桶插入当前桶后面。

if (!map.containsKey(key)) {
    if (head.next.cnt == 1) {
        map.put(key, head.next);
        head.next.set.add(key);
    } else {
        Bucket newBucket = new Bucket(key, 1);
        map.put(key, newBucket);
        insert(head, newBucket);
    }
}else {
    Bucket bucket = map.get(key);
    if (bucket.next.cnt == bucket.cnt + 1) {
        map.put(key, bucket.next);
        bucket.next.set.add(key);
    } else {
        Bucket newBucket = new Bucket(key, bucket.cnt + 1);
        map.put(key, newBucket);
        insert(bucket, newBucket);
    }
    bucket.set.remove(key);
    if (bucket.set.isEmpty()) {
        remove(bucket);  // 如果桶空了,删除该桶
    }
}

3. dec(key) - 减少计数

如果计数减到 0,需要从 map 中删除该 key，否则,向前移动到计数减 1 的桶。

public void dec(String key) {
    Bucket bucket = map.get(key);
    if (bucket.cnt == 1) {
        map.remove(key);  // 计数为0,彻底删除
    } else {
        if (bucket.last.cnt == bucket.cnt - 1) {
            map.put(key, bucket.last);
            bucket.last.set.add(key);
        } else {
            Bucket newBucket = new Bucket(key, bucket.cnt - 1);
            map.put(key, newBucket);
            insert(bucket.last, newBucket);
        }
    }
    bucket.set.remove(key);
    if (bucket.set.isEmpty()) {
        remove(bucket);
    }
}

4. getMaxKey() 和 getMinKey()

public String getMaxKey() {
    return tail.last.set.iterator().next();
}

public String getMinKey() {
    return head.next.set.iterator().next();
}

5.insert() - 在指定位置插入桶

private void insert(Bucket cur, Bucket pos) {
    cur.next.last = pos;
    pos.next = cur.next;
    cur.next = pos;
    pos.last = cur;
}

6.remove() - 删除桶

private void remove(Bucket cur) {
    cur.last.next = cur.next;
    cur.next.last = cur.last;
}

完整代码

class AllOne {
		class Bucket {
			public HashSet<String> set;
			public int cnt;
			public Bucket last;
			public Bucket next;

			public Bucket(String s, int c) {
				set = new HashSet<>();
				set.add(s);
				cnt = c;
			}
		}

		private void insert(Bucket cur, Bucket pos) {
			cur.next.last = pos;
			pos.next = cur.next;
			cur.next = pos;
			pos.last = cur;
		}


		private void remove(Bucket cur) {
			cur.last.next = cur.next;
			cur.next.last = cur.last;
		}

		Bucket head;                      // 哨兵头节点(cnt=0)
		Bucket tail;                      // 哨兵尾节点(cnt=MAX)
		HashMap<String, Bucket> map;      // key -> 所在桶的映射

		public AllOne() {
			head = new Bucket("",0);
			tail = new Bucket("",Integer.MAX_VALUE);
			head.next = tail;
			tail.last = head;
			map = new HashMap<>();
		}

		public void inc(String key){
			if(!map.containsKey(key)){
				if(head.next.cnt==1){
					map.put(key,head.next);
					head.next.set.add(key);
				}else {
					Bucket newBucket = new Bucket(key,1);
					map.put(key,newBucket);
					insert(head,newBucket);
				}
			}else{
				Bucket bucket = map.get(key);
				if(bucket.next.cnt==bucket.cnt+1){
					map.put(key,bucket.next);
					bucket.next.set.add(key);
				}else{
					Bucket newBucket = new Bucket(key, bucket.cnt+1);
					map.put(key,newBucket);
					insert(bucket,newBucket);
				}
				bucket.set.remove(key);
				if(bucket.set.isEmpty()){
					remove(bucket);// 如果桶空了,删除该桶
				}
			}
		}

		public void dec(String key){
			Bucket bucket = map.get(key);
			if(bucket.cnt==1){
				map.remove(key);// 计数为0,彻底删除
			}else{
				if(bucket.last.cnt==bucket.cnt-1){
					map.put(key,bucket.last);
					bucket.last.set.add(key);
				}else{
					Bucket newBucket = new Bucket(key,bucket.cnt-1);
					map.put(key,newBucket);
					insert(bucket.last,newBucket);
				}
			}
			bucket.set.remove(key);
			if(bucket.set.isEmpty()){
				remove(bucket);
			}
		}

		public String getMaxKey(){
			return tail.last.set.iterator().next();
		}

		public String getMinKey(){
			return head.next.set.iterator().next();
		}
	}

如果觉得有帮助,欢迎点赞关注! 🌟

LRU缓存淘汰算法Java实现

Tue, 21 Oct 2025 21:52:10 +0000

LRU的核心思想是当缓存空间满了,优先淘汰最久未被使用的数据。

这种思想其实在生活中也有，比如想象一下你的书桌只能放5本书。每次看完一本书,你就把它放在最右边。当需要放新书但桌面满了时,你会扔掉最左边那本(最久没看的)。这其实就是LRU的思想!

代码逻辑

1. addNode

public void addNode(DoubleNode newNode) {
    if (head == null) {
        // 链表为空,新节点既是头也是尾
        head = newNode;
        tail = newNode;
    } else {
        // 追加到尾部
        tail.next = newNode;
        newNode.last = tail;
        tail = newNode;
    }
}

2. moveNodeToTail

每次访问一个节点,都要把它移到尾部,表示"最近刚用过"。

public void moveNodeToTail(DoubleNode node) {
    if (tail == node) return;  // 已经在尾部
    
    // 从原位置摘除节点
    if (head == node) {
        head = node.next;
        head.last = null;
    } else {
        node.last.next = node.next;
        node.next.last = node.last;
    }
    
    // 追加到尾部
    node.last = tail;
    node.next = null;
    tail.next = node;
    tail = node;
}

3. removeHead

当缓存满了需要淘汰数据时,删除头部(最久未使用的)节点。

public DoubleNode removeHead() {
    if (head == null) return null;
    
    DoubleNode ans = head;
    if (head == tail) {
        // 只有一个节点
        head = null;
        tail = null;
    } else {
        head = ans.next;
        ans.next = null;
        head.last = null;
    }
    return ans;
}

4.get - 查询数据

public int get(int key) {
    if (keyNodeMap.containsKey(key)) {
        DoubleNode ans = keyNodeMap.get(key);
        nodeList.moveNodeToTail(ans);  // 标记为最近使用
        return ans.val;
    }
    return -1;
}

5.put - 插入或更新数据

public void put(int key, int value) {
    if (keyNodeMap.containsKey(key)) {
        // key已存在,更新value
        DoubleNode node = keyNodeMap.get(key);
        node.val = value;
        nodeList.moveNodeToTail(node);  // 移到尾部
    } else {
        // key不存在,插入新节点
        if (keyNodeMap.size() == capacity) {
            // 缓存已满,先淘汰最久未使用的
            DoubleNode removed = nodeList.removeHead();
            keyNodeMap.remove(removed.key);
        }
        
        DoubleNode newNode = new DoubleNode(key, value);
        keyNodeMap.put(key, newNode);
        nodeList.addNode(newNode);
    }
}

完整代码

class LRUCache{
		class DoubleNode {
			public int key;      // 键
			public int val;      // 值
			public DoubleNode last;  // 前驱节点
			public DoubleNode next;  // 后继节点
			public DoubleNode(int k, int v) {
				key = k;
				val = v;
			}
		}

		class DoubleList{
			private DoubleNode head;
			private DoubleNode tail;

			public DoubleList(){
				head = null;
				tail = null;
			}

			public void addNode(DoubleNode newNode) {
				if (head == null) {
					// 链表为空,新节点既是头也是尾
					head = newNode;
					tail = newNode;
				} else {
					// 追加到尾部
					tail.next = newNode;
					newNode.last = tail;
					tail = newNode;
				}
			}

			public void moveNodeToTail(DoubleNode node) {
				if (tail == node) return;  // 已经在尾部

				// 第一步: 从原位置摘除节点
				if (head == node) {
					head = node.next;
					head.last = null;
				} else {
					node.last.next = node.next;
					node.next.last = node.last;
				}

				// 第二步: 追加到尾部
				node.last = tail;
				node.next = null;
				tail.next = node;
				tail = node;
			}

			public DoubleNode removeHead() {
				if (head == null) return null;

				DoubleNode ans = head;
				if (head == tail) {
					// 只有一个节点
					head = null;
					tail = null;
				} else {
					head = ans.next;
					ans.next = null;
					head.last = null;
				}
				return ans;
			}
		}

		private HashMap<Integer, DoubleNode> keyNodeMap;
		private DoubleList nodeList;

		private final int capacity;

		public LRUCache(int cap){
			keyNodeMap = new HashMap<>();
			nodeList = new DoubleList();
			capacity = cap;
		}

		public int get(int key) {
			if (keyNodeMap.containsKey(key)) {
				DoubleNode ans = keyNodeMap.get(key);
				nodeList.moveNodeToTail(ans);  // 标记为最近使用
				return ans.val;
			}
			return -1;
		}

		public void put(int key, int value) {
			if (keyNodeMap.containsKey(key)) {
				// key已存在,更新value
				DoubleNode node = keyNodeMap.get(key);
				node.val = value;
				nodeList.moveNodeToTail(node);  // 移到尾部
			} else {
				// key不存在,插入新节点
				if (keyNodeMap.size() == capacity) {
					// 缓存已满,先淘汰最久未使用的
					DoubleNode removed = nodeList.removeHead();
					keyNodeMap.remove(removed.key);
				}
				DoubleNode newNode = new DoubleNode(key, value);
				keyNodeMap.put(key, newNode);
				nodeList.addNode(newNode);
			}
		}

	}

关注我,持续分享算法干货! 🚀

Leetcode148-排序链表

Sun, 19 Oct 2025 12:12:33 +0000

本文采用自底向上的归并排序来实现。

代码逻辑

1. findEnd函数

用于找到从某个节点开始，往后数k个节点的位置。

public static ListNode findEnd(ListNode s, int k) {
    while (s.next != null && --k != 0) {
        s = s.next;
    }
    return s;
}

2. merge函数

将两个有序部分合并成一个有序链表。

public static void merge(ListNode l1, ListNode r1, ListNode l2, ListNode r2) {
    ListNode pre;
    
    if (l1.val <= l2.val) {
        start = l1;
        pre = l1;
        l1 = l1.next;
    } else {
        start = l2;
        pre = l2;
        l2 = l2.next;
    }
    
    while (l1 != null && l2 != null) {
        if (l1.val <= l2.val) {
            pre.next = l1;
            pre = l1;
            l1 = l1.next;
        } else {
            pre.next = l2;
            pre = l2;
            l2 = l2.next;
        }
    }
    
    if (l1 != null) {
        pre.next = l1;
        end = r1;
    } else {
        pre.next = l2;
        end = r2;
    }
}

3. 处理流程

第一组的处理

l1 = head;
r1 = findEnd(l1, step);
l2 = r1.next;
r2 = findEnd(l2, step);
next = r2.next;

r1.next = null;
r2.next = null;

merge(l1, r1, l2, r2);
head = start; 
lastTeamEnd = end;

后续组的处理

while (next != null) {
    l1 = next;
    r1 = findEnd(l1, step);
    l2 = r1.next;
    
    if (l2 == null) {
        lastTeamEnd.next = l1;
        break;
    }
    
    r2 = findEnd(l2, step);
    next = r2.next;
    r1.next = null;
    r2.next = null;
    
    merge(l1, r1, l2, r2);
    lastTeamEnd.next = start;
    lastTeamEnd = end;
}

完整代码

public static ListNode sortList(ListNode head) {
		// 计算链表长度
		int n = 0;
		ListNode cur = head;
		while (cur != null) {
			n++;
			cur = cur.next;
		}

		ListNode l1, r1, l2, r2, next, lastTeamEnd;
		// 步长从1开始，每次翻倍（1→2→4→...）
		for (int step = 1; step < n; step <<= 1) {
			l1 = head;
			r1 = findEnd(l1, step);
			l2 = r1.next;
			r2 = findEnd(l2, step);
			next = r2.next;
			// 切断链表，确保l1-r1和l2-r2是独立的子链表
			r1.next = null;
			r2.next = null;
			// 合并两个子链表
			merge(l1, r1, l2, r2);
			// 更新头节点（第一次合并后，头可能变）
			head = start;
			lastTeamEnd = end;

			// 处理剩余的子链表
			while (next != null) {
				l1 = next;
				r1 = findEnd(l1, step);
				l2 = r1.next;
				// 如果只剩一个子链表，直接连接
				if (l2 == null) {
					lastTeamEnd.next = l1;
					break;
				}
				r2 = findEnd(l2, step);
				next = r2.next;
				r1.next = null;
				r2.next = null;
				merge(l1, r1, l2, r2);
				// 连接上一组的尾和当前组的头
				lastTeamEnd.next = start;
				lastTeamEnd = end;
			}
		}
		return head;
	}

	public static ListNode findEnd(ListNode s,int k){
		while(s.next!=null&&--k!=0){
			s=s.next;
		}
		return s;
	}

	public static ListNode start; // 合并后的头
	public static ListNode end;   // 合并后的尾

	public static void merge(ListNode l1, ListNode r1, ListNode l2, ListNode r2) {
		ListNode pre;
		// 确定合并后的头节点
		if (l1.val <= l2.val) {
			start = l1;
			pre = l1;
			l1 = l1.next;
		} else {
			start = l2;
			pre = l2;
			l2 = l2.next;
		}

		// 循环比较，合并节点
		while (l1 != null && l2 != null) {
			if (l1.val <= l2.val) {
				pre.next = l1;
				pre = l1;
				l1 = l1.next;
			} else {
				pre.next = l2;
				pre = l2;
				l2 = l2.next;
			}
		}

		// 处理剩余节点，确定合并后的尾
		if (l1 != null) {
			pre.next = l1;
			end = r1; // l1有剩余，尾是r1
		} else {
			pre.next = l2;
			end = r2; // l2有剩余，尾是r2
		}
	}

Floyd判圈算法

Sat, 18 Oct 2025 10:33:19 +0000

这个问题在实际开发中也有应用场景,比如检测循环引用、内存泄漏分析等。

本文介绍Floyd判圈算法来解决这道题。

代码逻辑

设置两个指针,慢指针(slow)每次走一步,快指针(fast)每次走两步。

如果链表存在环,快指针最终一定会追上慢指针；

如果链表不存在环,快指针会先到达链表末尾。

当快慢指针相遇后,问题就变成了:如何找到环的入口?

这里用到了一个的数学性质:

从起点到环入口的距离,等于从相遇点继续走到环入口的距离。

因此,我们只需将一个指针移回起点，然后两个指针都以相同速度前进，当它们再次相遇的位置,就是环的入口。

代码实现

public static ListNode detectCycle(ListNode head) {
    // 链表为空或节点数少于3个,不可能形成环
    if (head == null || head.next == null || head.next.next == null) {
        return null;
    }
    
    // 初始化快慢指针
    ListNode slow = head.next;
    ListNode fast = head.next.next;
    
    // 检测是否存在环
    while (slow != fast) {
        // 快指针到达末尾,说明无环
        if (fast.next == null || fast.next.next == null) {
            return null;
        }
        slow = slow.next;
        fast = fast.next.next;
    }
    
    // 找到环的入口
    // 将fast指针移回起点
    fast = head;
    // 两个指针以相同速度前进
    while (slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    
    // 相遇点即为环的入口
    return slow;
}

判断链表是否为回文

Fri, 17 Oct 2025 20:28:49 +0000

所谓回文，就是从前往后读和从后往前读都一样，比如 1→2→3→2→1 就是回文链表。

代码逻辑

1.找到链表的中点

ListNode slow = head, fast = head;
while (fast.next != null && fast.next.next != null) {
    slow = slow.next;
    fast = fast.next.next;
}

这里判断条件是 fast.next != null && fast.next.next != null，能保证 slow 最终停在中间偏左的位置，无论链表长度是奇数还是偶数都适用。

2.翻转后半部分链表

从中点开始，把后半部分链表反转。

反转后，链表变成了一个"双向箭头"的结构：前半部分从 head 指向中点，后半部分从尾部指向中点。

ListNode pre = slow;
ListNode cur = pre.next;
ListNode next = null;
pre.next = null;  // 断开前后两部分

while (cur != null) {
    next = cur.next;      // 保存下一个节点
    cur.next = pre;       // 反转指针
    pre = cur;            // pre 前进
    cur = next;           // cur 前进
}

3.双指针比对值

现在有两个指针：left 从头开始往右走，right 从尾开始往左走。

每一步比对两个节点的值，如果不相等就说明不是回文。

boolean ans = true;
ListNode left = head;
ListNode right = pre;

while (left != null && right != null) {
    if (left.val != right.val) {
        ans = false;
        break;
    }
    left = left.next;
    right = right.next;
}

4.恢复链表原状

判断完成后，不能把链表留成反转的状态，需要把后半部分再翻转回去。

cur = pre.next;
pre.next = null;
while (cur != null) {
    next = cur.next;
    cur.next = pre;
    pre = cur;
    cur = next;
}

完整代码

public static boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
        return true;
    }
    
    ListNode slow = head, fast = head;
    // 找中点
    while (fast.next != null && fast.next.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    
    // 翻转后半部分
    ListNode pre = slow;
    ListNode cur = pre.next;
    ListNode next = null;
    pre.next = null;
    while (cur != null) {
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    
    // 双指针比对
    boolean ans = true;
    ListNode left = head;
    ListNode right = pre;
    while (left != null && right != null) {
        if (left.val != right.val) {
            ans = false;
            break;
        }
        left = left.next;
        right = right.next;
    }
    
    // 恢复链表
    cur = pre.next;
    pre.next = null;
    while (cur != null) {
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    
    return ans;
}

复制带随机指针的链表

Thu, 16 Oct 2025 22:32:55 +0000

这道题的难点在于如何正确处理random指针的复制。

常规思路是使用哈希表建立旧节点到新节点的映射,但这需要O(n)的额外空间。

本文介绍一种空间复杂度O(1)的解法,核心是:

在原链表的每个节点后面紧跟着插入一个克隆节点。

1.创建克隆节点并插入原链表

遍历原链表,在每个原节点后面插入一个值相同的新节点,形成交替结构。

Node cur = head;
Node next = null;

while (cur != null) {
    next = cur.next;           // 保存下一个原节点
    cur.next = new Node(cur.val);  // 创建克隆节点
    cur.next.next = next;      // 克隆节点指向下一个原节点
    cur = next;                // 移动到下一个原节点
}

2.设置克隆节点的random指针

由于克隆节点紧跟在原节点后面，如果原节点A的random指向节点B，那么A的克隆节点A’的random应该指向B的克隆节点B’，而B’恰好就是B.next。

cur = head;
Node copy = null;

while (cur != null) {
    next = cur.next.next;      // 下一个原节点
    copy = cur.next;           // 当前的克隆节点
    // 如果原节点的random不为空,
    // 则克隆节点的random指向原节点random的下一个节点(即克隆节点)
    copy.random = cur.random != null ? cur.random.next : null;
    cur = next;
}

3.分离新旧链表

把交织在一起的新旧链表分离开,恢复原链表的结构,同时得到独立的新链表。

Node ans = head.next;  // 新链表的头节点
cur = head;

while (cur != null) {
    next = cur.next.next;      // 下一个原节点
    copy = cur.next;           // 当前克隆节点
    cur.next = next;           // 恢复原链表连接
    // 连接克隆链表
    copy.next = next != null ? next.next : null;
    cur = next;
}

return ans;

完整代码：

public static Node copyRandomList(Node head) {
    if (head == null) {
        return null;
    }
    
    Node cur = head;
    Node next = null;
    
    // 创建克隆节点并插入
    while (cur != null) {
        next = cur.next;
        cur.next = new Node(cur.val);
        cur.next.next = next;
        cur = next;
    }
    
    cur = head;
    Node copy = null;
    
    // 设置random指针
    while (cur != null) {
        next = cur.next.next;
        copy = cur.next;
        copy.random = cur.random != null ? cur.random.next : null;
        cur = next;
    }
    
    Node ans = head.next;
    cur = head;
    
    // 分离链表
    while (cur != null) {
        next = cur.next.next;
        copy = cur.next;
        cur.next = next;
        copy.next = next != null ? next.next : null;
        cur = next;
    }
    
    return ans;
}

K个一组翻转链表-一道让人头疼的算法题

Wed, 15 Oct 2025 20:51:43 +0000

这道题的难点不在于算法本身，而在于细节处理。

代码逻辑

1.定位组的结束节点

从起始节点s开始，往后走k-1步，找到当前组的最后一个节点。如果中途遇到null，说明不足k个节点。

public static ListNode teamEnd(ListNode s, int k) {
    while (--k != 0 && s != null) {
        s = s.next;
    }
    return s;
}

2.翻转一组节点

提前保存e.next，这样翻转完成后，原来的起始节点s可以直接连接到下一组。

public static void reverse(ListNode s, ListNode e) {
    e = e.next;  // 先保存下一组的起始节点
    ListNode pre = null, cur = s, next = null;
    while (cur != e) {
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    s.next = e;  // 翻转后，原来的起始节点要连接到下一组
}

3.主函数

public static ListNode reverseKGroup(ListNode head, int k) {
    ListNode start = head;
    ListNode end = teamEnd(start, k);
    if (end == null) {
        return head;  // 第一组不足k个，直接返回
    }
    
    // 第一组特殊处理：需要更新头节点
    head = end;
    reverse(start, end);
    ListNode lastTeamEnd = start;  // 翻转后start变成了上一组的尾节点
    
    // 处理后续各组
    while (lastTeamEnd.next != null) {
        start = lastTeamEnd.next;
        end = teamEnd(start, k);
        if (end == null) {
            return head;  // 当前组不足k个，保持原样
        }
        reverse(start, end);
        lastTeamEnd.next = end;  // 连接上一组和当前组
        lastTeamEnd = start;     // 更新上一组的尾节点
    }
    return head;
}

完整代码

public static ListNode reverseKGroup(ListNode head, int k) {
		ListNode start = head;
		ListNode end = teamEnd(start, k);
		if (end == null) {
			return head;  // 第一组不足k个，直接返回
		}

		// 第一组特殊处理：需要更新头节点
		head = end;
		reverse(start, end);
		ListNode lastTeamEnd = start;  // 翻转后start变成了上一组的尾节点

		// 处理后续各组
		while (lastTeamEnd.next != null) {
			start = lastTeamEnd.next;
			end = teamEnd(start, k);
			if (end == null) {
				return head;  // 当前组不足k个，保持原样
			}
			reverse(start, end);
			lastTeamEnd.next = end;  // 连接上一组和当前组
			lastTeamEnd = start;     // 更新上一组的尾节点
		}
		return head;
	}


	//定位组的结束节点
	public static ListNode teamEnd(ListNode s, int k){
		while(--k!=0&&s!=null){
			s=s.next;
		}
		return s;
	}

	public static void reverse(ListNode s, ListNode e) {
		e = e.next;  // 先保存下一组的起始节点
		ListNode pre = null, cur = s, next = null;
		while (cur != e) {
			next = cur.next;
			cur.next = pre;
			pre = cur;
			cur = next;
		}
		s.next = e;  // 翻转后，原来的起始节点要连接到下一组
	}

一次遍历找到链表交点的优雅解法

Tue, 14 Oct 2025 20:33:43 +0000

需要注意的是，这里的"相交"是指两个链表在某个节点处合并，之后共享剩余的节点。

这道题的关键在于:如果两个链表相交,它们一定有共同的尾节点。

1.首先遍历两个链表，计算两个链表的长度差，然后找到各自的尾节点。

ListNode a = h1, b = h2;
int diff = 0;
while (a.next != null) {
    a = a.next;
    diff++;
}
while (b.next != null) {
    b = b.next;
    diff--;
}
if (a != b) {
    return null;
}

用一个变量diff同时记录长度差。

遍历h1时diff++,遍历h2时diff–,最终diff就是两个链表的长度差。

遍历结束后,如果a != b,说明两个链表的尾节点不同,必然不相交。

2.让较长的链表先走若干步,消除长度差。

if (diff >= 0) {
    a = h1;  // h1更长
    b = h2;
} else {
    a = h2;  // h2更长
    b = h1;
}
diff = Math.abs(diff);
while (diff-- != 0) {
    a = a.next;  // 长链表先走
}

3.两个指针距离各自链表尾部的距离相同,接下来同步前进,第一个相同的节点就是交点。

while (a != b) {
    a = a.next;
    b = b.next;
}
return a;

完整代码

public static ListNode getIntersectionNode(ListNode h1,ListNode h2){
		if(h1==null||h2==null){
			return null;
		}
		ListNode a = h1,b=h2;
		int diff =0 ;
		//计算长度差，找到h1的尾节点
		while(a.next!=null){
			a=a.next;
			diff++;
		}

		//计算长度差，找到h2的尾节点
		while(b.next!=null){
			b= b.next;
			diff--;
		}

		//尾节点不同，不相交
		if(a!=b){
			return null;
		}
		//让a指向较长的链表，b指向较短的链表
		if(diff>=0){
			a=h1;
			b=h2;
		}else{
			a=h2;
			b=h1;
		}
		//长链表先走diff步
		diff=Math.abs(diff);
		while(diff--!=0){
			a=a.next;
		}

		//同步前进，找到交点
		while(a!=b){
			a=a.next;
			b=b.next;
		}
		return a;
	}

用堆秒杀「合并-K-个已排序的链表」

Mon, 06 Oct 2025 19:08:27 +0000

这道题的思路是用小根堆 “盯紧” 最小节点。

核心步骤如下：

先把 K 个链表的头节点放进小根堆，这样堆顶就是当前最小节点；
每次从堆顶取出最小节点，加入结果链表；
再把这个最小节点的下一个节点放进堆里（如果有的话）；
重复步骤 2-3，直到堆为空，所有节点都被合并。

1.初始化小根堆

Java 的PriorityQueue默认是小根堆，但这里显式传入比较器(a, b) -> a.val - b.val，确保按节点值升序排序。

`1`	`PriorityQueue<ListNode> heap = new PriorityQueue<>((a, b) -> a.val - b.val);`

2.加入所有链表的头节点

遍历输入的 K 个链表，把非空的头节点加入堆。

for (ListNode h : arr) {
    if (h != null) {
        heap.add(h);
    }
}

3. 构建结果链表的头部

先从堆顶取出最小的节点（h），作为结果链表的头节点。

用pre指针跟踪结果链表的尾部。

把h的下一个节点加入堆（如果存在）。

ListNode h = heap.poll();
ListNode pre = h;
if (pre.next != null) {
    heap.add(pre.next);
}

4.循环合并剩余节点

每次从堆顶取最小节点cur，拼到pre后面，然后pre移到cur。

再把cur的下一个节点加入堆。

while (!heap.isEmpty()) {
    ListNode cur = heap.poll();  
    pre.next = cur;             
    pre = cur;                  
    if (cur.next != null) {
        heap.add(cur.next);      
    }
}

完整代码

链接：https://pan.quark.cn/s/8a7bb143e196 提取码：dXXp

归并排序的递归和非递归实现

Thu, 02 Oct 2025 12:59:31 +0000

归并排序的本质是 “分治”：

把大数组拆成小数组，各自排好序后，再合并成一个有序数组。

就像把一堆乱牌分成两半，每半先理好，再把两堆理好的牌一张张比对，按顺序合成一堆 —— 这就是 “分” 和 “合” 的过程。

下面看一道Leetcode题：

递归实现

public class Main {
	public static int[] sortArray(int[] nums){
		// 数组长度大于1时才需要排序（长度为0或1默认有序）
		if(nums.length>1){
			mergeSort(nums);
		}
		return nums;
	}

	// 定义最大数组长度
	public static int MAXN = 50001;
	// 辅助数组：用于归并过程中临时存储元素，避免每次合并都新建数组
	public static int[] help = new int[MAXN];

	public static void mergeSort(int[] arr){
		// 从数组的0号位置到最后一个位置（arr.length-1）进行排序
		sort(arr,0,arr.length-1);
	}

	public static void sort(int[] arr,int l,int r){
		// 当区间只有一个元素时（l==r），无需排序，直接返回
		if(l==r){
			return;
		}

		// 计算中间位置（等价于(l+r)/2，但用位运算>>1避免溢出，且效率更高）
		int m = l + ((r - l) >> 1);
		// 递归排序左半区间 [l, m]
		sort(arr,l,m);
		// 递归排序右半区间 [m+1, r]
		sort(arr,m+1,r);
		// 合并左右两个已排序的区间
		merge(arr,l,m,r);
	}

	public static void merge(int[] arr,int l,int m,int r){
		int i = l;       // 辅助数组help的当前填充位置（从l开始）
		int a = l;       // 左区间的遍历指针（从l开始）
		int b = m + 1;   // 右区间的遍历指针（从m+1开始）

		// 1. 双指针遍历左右区间，将较小的元素依次放入help
		while(a <= m && b <= r){
			// 谁小就先放谁，相等时优先放左区间元素（保证稳定性）
			help[i++] = arr[a] <= arr[b] ? arr[a++] : arr[b++];
		}

		// 2. 左区间还有剩余元素，全部放入help（右区间已遍历完）
		while(a <= m){
			help[i++] = arr[a++];
		}

		// 3. 右区间还有剩余元素，全部放入help（左区间已遍历完）
		while(b <= r){
			help[i++] = arr[b++];
		}

		// 4. 将help中排序好的元素拷贝回原数组的[l, r]区间
		for(i = l; i <= r; i++){
			arr[i] = help[i];
		}
	}

}

非递归实现

public class Main {

	public static int[] sortArray(int[] nums){
		if(nums.length>1){
			mergeSort(nums);
		}
		return nums;
	}

	public static int MAXN = 50001;
	public static int[] help = new int[MAXN];

	public static void mergeSort(int[] arr){
		int n = arr.length;
		// step：当前要合并的子数组长度，初始为1（单个元素默认有序），每次翻倍（左移1位等价于×2）
		// 循环条件：step < n（当子数组长度超过数组长度时，排序完成）
		for(int step=1; step < n; step <<= 1){
			int l = 0; // 每次合并的起始位置，从0开始

			// 遍历数组，按当前step划分并合并子数组
			while(l < n){
				// m：左子数组的结束位置（左子数组范围 [l, m]，长度为step）
				int m = l + step - 1;
				// 若右子数组起始位置（m+1）已超出数组范围，说明只剩一个子数组，无需合并
				if(m + 1 >= n){
					break;
				}
				// r：右子数组的结束位置（右子数组最大长度为step，取较小值避免越界）
				int r = Math.min(l + (step << 1) - 1, n - 1);

				// 合并 [l, m] 和 [m+1, r] 两个有序子数组
				merge(arr, l, m, r);

				// 移动到下一组子数组的起始位置
				l = r + 1;
			}
		}
	}

	public static void merge(int[] arr,int l,int m,int r){
		int i=l;
		int a = l;
		int b = m+1;
		while(a<=m&&b<=r){
			help[i++]=arr[a]<=arr[b]?arr[a++]:arr[b++];
		}

		while(a<=m){
			help[i++]=arr[a++];
		}

		while(b<=r){
			help[i++]=arr[b++];
		}

		for(i=l;i<=r;i++){
			arr[i]=help[i];
		}
	}

}

代码文件 链接：https://pan.quark.cn/s/fc867494224a 提取码：9nSb