[Java 算法 ] 链表

练习一 : 两数相加

2. 两数相加 - 力扣（LeetCode）

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode();
        ListNode prev = newHead;
        ListNode cur1 = l1,cur2 = l2;
        int t = 0;
        while(cur1!=null||cur2!=null||t!=0){
            ListNode node = new ListNode();
            if(cur1!=null){
                t+=cur1.val;
                cur1 = cur1.next;
            }
            if(cur2!=null){
                t+=cur2.val;
                cur2 = cur2.next;
            }
            prev.next = node;
            prev = prev.next;
            node.val = t%10;
            t /=10;
        }
        return newHead.next;
    }
}

算法原理

• 两个链表从左到右 就是数字的个位、十位、百位......
• 每一位相加 = 链表 1 当前值 + 链表 2 当前值 + 上一位的进位
• 当前位结果 = 和 % 10
• 进位 = 和 / 10
• 直到两个链表都走完 + 进位也为 0，结束

练习二 : 两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null||head.next == null){
            return head;
        }
        ListNode newHead = new ListNode(0);
        newHead.next = head;

        ListNode prev = newHead,cur = head,curN = cur.next,curNN;
        
        while(cur != null && curN != null){
            curNN = curN.next;  // 每次循环重新取
            
            prev.next = curN;
            curN.next = cur;
            cur.next = curNN;

            prev = cur;  
            cur = curNN;
            
            if(cur != null) curN = cur.next;
            else curN = null;
        }

        return newHead.next;
    }
}

算法原理

迭代 + 三指针 + 哨兵节点

1. 用哨兵节点统一头节点和普通节点的交换逻辑
2. 每次处理两个节点：cur 和 curN
3. 交换步骤：
   • 前驱节点指向第二个节点
   • 第二个节点指向第一个节点
   • 第一个节点指向后面的节点
4. 交换完，指针移动到下一对
5. 直到后面不足两个节点，停止

练习三 : 合并 k 个升序链表

23. 合并 K 个升序链表 - 力扣（LeetCode）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> queue = new PriorityQueue<>((v1,v2)->v1.val-v2.val);
        for(ListNode t: lists){//将数组中的元素放入链表中, 存的全是链表的头结点
            if(t!=null) queue.offer(t);
        }
        ListNode newHead = new ListNode(0);
        ListNode prev = newHead;
        while(!queue.isEmpty()){
            ListNode cur = queue.poll();
            prev.next = cur;
            prev = cur;
            if(cur.next!=null) queue.offer(cur.next);
        }
        return newHead.next;
    }
}

算法原理

最小堆（小根堆）+ 贪心算法

1. 把所有链表的头节点放进堆
2. 堆会自动把最小的节点放到堆顶
3. 每次取出最小值，接到结果链表
4. 把这个节点的下一个节点再放进堆
5. 重复直到堆空