链表问题汇总

已于 2024-06-16 11:09:32 修改
阅读量614 收藏 21
点赞数 21
文章标签： 链表 java 数据结构 leetcode
于 2024-06-14 23:51:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41644412/article/details/139677005
版权

目录

一、链表

0、链表结构定义

1、leetcode2: 两数相加

2、leetcode19: 删除倒数第N个节点

3、leetcode21: 合并两个排序链表

4、leetcode23: 合并k个有序连表

5、leetcode24: 交换相邻节点

6、leetcode25: k个一组反转连表

7、leetcode61: 将链表往后旋转k位

8、leetcode82: 删除排序链表中所有重复节点【易错】

9、leetcode83: 删除排序链表中的重复节点【重复节点只保留一个】

10、leetcode86: 分割链表【=x的在x右边，位置不变】的在x左边，>

11、leetcode92: 反转链表II

12、leetcode109: 有序链表转二叉搜索树

13、leetcode141: 判断链表是否有环

14、leetcode142: 找到环形链表的入口

15、leetcode143: 链表重排序

16、leetcode147: 链表插入排序

17、leetcode148: 排序链表

18、leetcode160: 判断两个链表是否相交

19、leetcode203: 移除链表元素

20、leetcode206: 反转链表

21、leetcode234: 判断链表是否是回文链表

22、leetcode237: 删除链表中的节点【无法通过头节点删除】

23、leetcode328: 奇偶链表

24、leetcode445: 两数相加II

一、链表

0、链表结构定义

public class ListNode{
    private ListNode next;
    private int val;   
    
    public ListNode(int val){
        this.val = val;
    }
}

1、leetcode2: 两数相加

题目描述：链表表示数据，例如[2,4,3] 表示342.求两个链表的和。结果正序表示。

例如: [2,4,3] + [5,6,4] = [7,0,8]

public static ListNode problem2_TwoSum(ListNode l1, ListNode l2){
    if(l1 == null) return l2;
    if(l2 == null) return l1;

    ListNode res = new ListNode(-1), tmp = res;
    int carry = 0;
    while(l1 != null || l2 != null) {
        int num1 = l1 == null ? 0 : l1.val;
        int num2 = l2 == null ? 0 : l2.val;
        int sum = num1 + num2 + carry;
        tmp.next = new ListNode(sum % 10);
        carry = sum/10;
              
        if(l1 != null) l1 = l1.next;
        if(l2 != null) l2 = l2.next;
        tmp = tmp.next;
    }
    if (carry > =) tmp.next = new ListNode(carry);
    return res.next;
}

2、leetcode19: 删除倒数第N个节点

题目描述：删除链表的倒数第N个节点。

例如：[1,2,3,4,5]， n = 2。 输出[1,2,3,5]

解法思路: 双指针。快指针先走n步，然后快慢指针一起走

private static ListNode problem19_deleteLastNNode(ListNode head, int n) {
    if(head == null || n <= 0) return head;
    ListNode res = new ListNode(-1), fast = res, slow = res;
    res.next = head;
    for(int i = 0; i<n && fast != null; i++) {
        fast = fast.next;
    }
    if( fast == null) return head;
    while(fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return res.next;
}

3、leetcode21: 合并两个排序链表

题目描述：合并两个有序连表。

例如: [1,2,4] + [1,3,4] = [1,1,2,3,4,4]

private static ListNode problem21_MergeTwoSortedLinkedList(ListNode l1, ListNode l2) {
    if(l1 == null) return l2;
    if(l2 == null) return l1;
    ListNode res = new ListNode(-1), tmp = res;
    while(l1 != null && l2 != null) {
        if(l1.val <= l2.val) {
            tmp.next = l1;
            l1 = l1.next;        
        }else {
            tmp.next = l2;
            l2 = l2.next; 
        }
        tmp = tmp.next;
    }
    if(l1 != null) tmp.next = l1;
    if(l2 != null) tmp.next = l2;
    return res.next;
}

4、leetcode23: 合并k个有序连表

题目描述: 合并k个有序连表

解法思路: 使用优先队列。将链表头节点塞入优先队列，poll出最小的连表节点，改变指针指向。如果还有子节点，继续塞入队列中。

private static ListNode problem21_MergeKSortedLinkedList(ListNode[] lists) {
    if(lists == null || lists.length == 0) return null;
    if(lists.length == 1) return lists[0];
    PriorityQueue<ListNode> queue = new PriorityQueue<ListNode>(lists.length, (o1, o2) -> {return o1.val - o2.val;});
    // 优先队列添加有序连表头节点
    for(int i = 0; i< lists.length; i++) {
        if(lists[i] != null) {
            queue.add(lists[i]);
        }
    }
    
    ListNode res = new ListNode(-1), tmp = res;
    while(!queue.isEmpty()) {
        ListNode node = queue.poll();
        ListNode next = node.next;
        node.next = null;
        tmp.next = node;
        tmp = tmp.next;
        if(next != null) queue.add(next);
    }
    return res.next;
}

5、leetcode24: 交换相邻节点

题目描述：交换连表相邻的两个节点

例1: [1,2,3,4].输出 [2,1,4,3]

例2: [1,2,3,4,5].输出 [2,1,4,3,5]

// 1,2,3,4 -> 2,1,4,3
// 1,2,3,4, 5 -> 2,1,4,3,5
private static ListNode problem24_ExchangeNodeNearby(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode res = new ListNode(-1), tmp = res, current = head, next, next2;
    while(current != null) {
        next = current.next;
        if(next == null) break;
        next2 = next.next;
        tmp.next = next;
        next.next = current;
        current.next = next2;
        tmp = current;
        current = next2;
    }
    return res.next;
}

6、leetcode25: k个一组反转连表

题目描述: k个节点一组反转链表

例1: [1,2,3,4,5], 2个一组反转。输出: [2,1,4,3,5]

/**
 * 例如: [1,2,3,4,5] k=2 -> [2,1,4,3,5] 
 * 解法思路: 反转链表升级版，每次走k步，截断链表，反转之后在连接上去
 */
private static ListNode problem25_ReverseByKNode(ListNode head, int k) {
    if(head == null || head.next == null || k<= 1) return head;
    
    ListNode res = new ListNode(-1), tmp = res, current = head, start, next;
    tmp.next = head;
    while(current != null) {
        start = current;
        for(int i = 0; i<k-1 && current != null; i++) {
            current = current.next;
        }
        if(current == null) break;
        next = current.next;
        current.next = null;
        // 注意: 此处反转之后，头节点变成current,尾节点是start
        tmp.next = reverse(start);
        start.next = next;
        tmp = start;
        current = next;
    }

    return res.next;
}

public static ListNode reverse(ListNode head){
    if(head == null || head.next == null) return head;
    ListNode node = reverse(head.next);
    head.next.next = head;
    head.next = null;
    return node;    
}

7、leetcode61: 将链表往后旋转k位

题目描述: 链表旋转k位.

例如: [1,2,3,4,5], k=2|7。输出[4,5,1,2,3]

/** 
 * 例1: [1,2,3,4,5] k=2 -> [4,5,1,2,3]
 * 例2: [0,1,2] k = 4 -> [2,0,1]
 * 解法思路: 先获取链表长度，对k取余数，将余数后对节点截断链接至头节点前
 */
private static ListNode problem61_RotateLinkedListByK(ListNode head, int k) {
    if(head == null || head.next == null || k<=0) return head;
    // TODO 获取链表长度时可以用一个全局变量保存链表尾节点，避免在遍历一次
    int len = getListNodeLen(head);
    int step = len - (k % len);
    if(step == 0) return head;
    ListNode res = new ListNode(-1), tmp = res;
    tmp.next = head;
    // 注意，如果是左移2位，前面剩下的是len-2个
    for(int i = 0; i<len-step; i++) {
        tmp = tmp.next;    
    }
    ListNode next = tmp.next;
    tmp.next = null;
    res.next = next;
    while(next.next != null){
        next = next.next;
    }
    next.next = head;
    return res.next;
}

public static int getListNodeLen(ListNode head) {
    int len = 0;    
    ListNode tmp = head;
    while(tmp != null) {
        len++;
        tmp = tmp.next;
    }
    return len;
}

8、leetcode82: 删除排序链表中所有重复节点【易错】

题目描述：删除链表中所有重复的节点【重复的一个不留】

例如: [1,2,3,3,4,4,5]。输出: [1,2,5]

private static ListNode problem82_DeletedAllDuplicateNode(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode res = new ListNode(-1), tmp = res;
    tmp.next = head;
    while(tmp != null) {
        if(tmp.next != null && tmp.next.next != null && tmp.next.val == tmp.next.next.val) {
            int duplicateVal = tmp.next.val;
            while(tmp.next != null && tmp.next.val == duplicateVal) {
                tmp.next = tmp.next.next;
            }
        }else {
            tmp = tmp.next;
        }
    }
    return res.next;
}

9、leetcode83: 删除排序链表中的重复节点【重复节点只保留一个】

题目描述：删除链表中所有重复的节点【重复的留一个】

例如: [1,2,3,3,4,4,5]。输出: [1,2,3,4,5]

private static ListNode problem83_DeletedDuplicateNode(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode res = new ListNode(-1), tmp = res;
    tmp.next = head;
    while(tmp != null) {
        while(tmp.next != null && tmp.next.next != null && tmp.next.val == tmp.next.next.val) {
            tmp.next = tmp.next.next;
        }
        tmp = tmp.next;
    }
    return res.next;
}

10、leetcode86: 分割链表【<x的在x左边，>=x的在x右边，位置不变】

题目描述：以x分割链表，使得小于x的出现在左侧。节点的相对位置不变

例1: [1,4,3,2,5,2], x=3， 输出： [1,2,2,4,3,5] ； 例2: [2,1], x=2， 输出： [1,2]

解法: 一次遍历，小于x的和大于等于x的分成两个链表，然后拼接

private static ListNode problem86_SplitLinkedListNode(ListNode head, int x) {
    if(head == null || head.next == null) return head;
    ListNode leftHead = new ListNode(-1), leftTmp = leftHead;
    ListNode rightHead = new ListNode(-1), rightTmp = rightHead;
    ListNode tmp = head;

    while(tmp != null){
        if(tmp.val < x){
            leftTmp.next = tmp;
            leftTmp = leftTmp.next;
        }else {
            rightTmp.next = tmp;
            rightTmp = rightTmp.next;
        }

        ListNode next = tmp.next;
        tmp.next = null;
        tmp = next;
    }

    if(leftHead.next == null) {
        return rightHead.next;    
    }

    leftTmp.next = rightHead.next;
    return leftHead.next;
}

11、leetcode92: 反转链表II

题目描述： 反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

例如：[1,2,3,4,5] left= 2, right = 4。输出： [1,4,3,2,5]

// left、right代表的是位置. 1,2,3,4,5
private static ListNode problem92_ReverseListNodeII(ListNode head, int left, int right) {
    if(head == null || head.next == null || left >= right) return head;
    ListNode res = new ListNode(-1), tmp = res, start, pre = null, next;
    tmp.next = head;
    for(int i=0; i<left && tmp != null; i++) {
        pre = tmp;
        tmp = tmp.next;
    }     
    if(tmp == null) return head;
    start = tmp;
    for(int i=0; i<right-left && tmp != null; i++) {
        tmp = tmp.next;
    }
    if(tmp == null) return head;
    next = tmp.next;
    tmp.next = null;
    pre.next = reverse(start);
    start.next = next;
    return res.next;
}

public static ListNode reverse(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode node = reverse(head.next);
    head.next.next = head;
    head.next = null;
    return node;    
}

12、leetcode109: 有序链表转二叉搜索树

题目描述：给一个升序链表，转换成平衡二叉树

例如：[-10,-3,0,5,9] ， 层序遍历二叉树输出：[[0],[-3,9],[-10,null,5]]

// 有序链表转二叉搜索树：通过中序遍历(左中右)实现。
private static TreeNode problem109_sortedListToBST(ListNode head) {
    // 递归出口1: 空节点
    if(head == null) return null;
    ListNode rightMid = findMidAndSplitListNode(head);
    TreeNode root = new TreeNode(rightMid.val);
    // 递归出口2: 只有一个节点。说明是叶子节点
    if(rightMid == head){
        return root;
    }
    
    root.left = problem109_sortedListToBST(head);
    root.right = problem109_sortedListToBST(rightMid.next);
    return root;
}

// -10,-3,0,5,9: 返回0
public static ListNode findMidAndSplitListNode(ListNode head) {
    ListNode fast = new ListNode(-1), slow = fast;
    fast.next = head;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    ListNode rightMid = slow.next;
    slow.next = null;
    return rightMid;
}

13、leetcode141: 判断链表是否有环

// 判断是否是有环: 快慢指针。相等说明有环
private static boolean problem141_IsRecycleLinkedList(ListNode head) {
    if(head == null || head.next == null) return false;
    ListNode fast = head, slow = head;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
        if(fast == slow) return true;
    }
    return false;
}

14、leetcode142: 找到环形链表的入口

private static ListNode problem142_IsRecycleLinkedListII(ListNode head) {
    if(head == null) return null;
    ListNode fast = head, slow = head;
    boolean hasCycle = false;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
        if(fast == slow) {
            hasCycle = true;
            break;
        }
    }
    if(!hasCycle) return null;
    slow = head;
    while(slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
}

15、leetcode143: 链表重排序

题目描述：给定一个单链表 L 的头节点 head ，单链表 L 表示为：L0 → L1 → … → Ln - 1 → Ln。请将其重新排列后变为：L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …。不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

解法分析：将链表拆分成两段；第二段反转；拼接两个链表

private static void problem143_ResortListNode(ListNode head) {
    if(head == null || head.next == null) return;
    ListNode rightMid = findMidAndSplitListNode(head);
    merge(head, reverse(rightMid));
}

public static ListNode findMidAndSplitListNode(ListNode head) {
    ListNode fast = head, slow = fast;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    ListNode rightMid = slow.next;
    slow.next = null;
    return rightMid;
}

public static ListNode reverse(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode node = reverse(head.next);
    head.next.next = head;
    head.next = null;    
    return node;
}

public static void merge(ListNode l1, ListNode l2) {
    ListNode l1Tmp, l2Tmp;
    while(l1 != null && l2 != null) {
        l1Tmp = l1.next;
        l2Tmp = l2.next;

        l1.next = l2;
        l2.next = l1Tmp;
        l1 = l1Tmp;
        l2 = l2Tmp;
    }
}

16、leetcode147: 链表插入排序

// 插入排序的原理: 遍历将节点插入他应该在的位置
// [4,2,1,3] -> [1,2,3,4]
private static ListNode problem147_InsertSortListNode(ListNode head) {
    if(head == null || head.next == null) return head;

    ListNode current = head, res = new ListNode(-1), p = res;
    res.next = head;
    while(current.next != null) {
        if(current.val <= current.next.val) {
            current = current.next;
            continue;
        }
        
        ListNode node = current.next;
        current.next = current.next.next;

        p = res;
        while(p.next.val < node.val) {
            p = p.next;
        }
        ListNode next = p.next;
        p.next = node;
        node.next = next;
    }
    return res.next;
}

17、leetcode148: 排序链表

解题思路: 采用分治法。从排序链表中间点分割成两个独立的链表【拆分到单个节点】，然后合并两个排序链表


private static ListNode problem148_SortListNode(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode rightMid = findMidAndSplit(head);
    ListNode l1 = problem148_SortListNode(head);
    ListNode l2 = problem148_SortListNode(rightMid);
    return mergeTwoSortedListNode(l1, l2);
}

public static ListNode findMidAndSplit(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode fast = new ListNode(-1), slow = fast;
    fast.next = head;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    ListNode node = slow.next;
    slow.next = null;
    return node;
}

public static ListNode mergeTwoSortedListNode(ListNode l1, ListNode l2) {
    if(l1 == null) return l2;
    if(l2 == null) return l1;
    ListNode res = new ListNode(-1), tmp = res;
    while(l1 != null && l2 != null) {
        if(l1.val < l2.val) {
            tmp.next = l1;
            l1 = l1.next;
        }else {
            tmp.next = l2;
            l2 = l2.next;
        }
        tmp = tmp.next;
    }
    tmp.next = l1 == null ? l2 : l1;
    return res.next;
}

18、leetcode160: 判断两个链表是否相交

解题思路： 两个指针p、q分别从headA和headB往后遍历，如果为null了切换到另一个头节点。p、q相等【java中 == 比较对象时比较的是内存地址】说明相交。

private static ListNode problem160_CrossListNode(ListNode headA, ListNode headB) {
    if(headA == null || headB == null) return null;
    ListNode p = headA, q = headB;

    // 如果headA和headB不相交，那么最后p=q=null     
    while(p != q) {
        p = p != null ? p.next : headB;
        q = q != null ? q.next : headA;
    }
    return p;
}

19、leetcode203: 移除链表元素

题目描述：移除链表中val 等于 给定x的所有节点。

private static ListNode problem203_RemoveListNode(ListNode head, int deleteVal) {
    if (head == null) return null;
    ListNode res = new ListNode(-1), tmp = res;
    tmp.next = head;
    while(tmp.next != null) {
        if(tmp.next.val == deleteVal) {
            tmp.next = tmp.next.next;
        }else {
            tmp = tmp.next;
        }
    }   
    return res.next;
}

20、leetcode206: 反转链表

// 递归
private static ListNode problem206_ReverseListNode(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode node = problem206_ReverseListNode(head.next);
    head.next.next = head;
    head.next = null;
    return node;
}

// 迭代
private static ListNode problem206_ReverseListNode(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode current = head, pre, next;
    while(current != null) {
        next = current.next;
        current.next = pre;
        pre = current;
        current = next;
    }
    return pre;
}

21、leetcode234: 判断链表是否是回文链表

解题思路：找到链表的中点，分成两个链表。后面的反转，然后对比。

private static boolean problem234_HuiWenListNode(ListNode head) {
    if(head == null) return false;   
    if(head.next == null) return true;
    
    ListNode rightMid = findAndSplit(head);
    rightMid = reverse(rightMid);
    return isHuiwen(head, rightMid);
}

public static ListNode findAndSplit(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode fast = head, slow = head;
    while(fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    ListNode rightMid = slow.next;
    slow.next = null;
    return rightMid;
}

public static ListNode reverse(ListNode head) {
    if(head == null || head.next == null) return head;
    ListNode node = reverse(head.next);
    head.next.next = head;
    head.next = null;
    return node;
}

public static boolean isHuiwen(ListNode p, ListNode q){
    while(p != null && q != null) {
        if(p.val == q.val) {
            p = p.next;
            q = q.next;
        }else {
            return false;
        }
    }

    return lengthIsOne(p) && lengthIsOne(q);
}

public static boolean lengthIsOne(ListNode head) {
    return head == null || head.next == null;
}

22、leetcode237: 删除链表中的节点【无法通过头节点删除】

问题描述：给你一个需要删除的节点 node 。你将 无法访问 第一个节点  head。链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

  • 给定节点的值不应该存在于链表中。
  • 链表中的节点数应该减少 1。
  • node 前面的所有值顺序相同。
  • node 后面的所有值顺序相同。
private static void problem237_RemoveListNode(ListNode node) {
    node.val = node.next.val;
    ListNode next = node.next.next;
    node.next.next = null;
    node.next = next;
}

23、leetcode328: 奇偶链表

题目描述：给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

解题思路：一次遍历，将节点拆分成奇数和偶数链表，然后拼接到一起。

// [1,2,3,4,5] -> [1,3,5,2,4]
private static ListNode problem328_OddEvenListNode(ListNode head) {
    if(head == null || head.next == null) return head;

    ListNode oddHead = new ListNode(-1), oddTmp = oddHead;
    ListNode evenHead = new ListNode(-1), evenTmp = evenHead;
    boolean odd = true;

    while(head != null) {
        ListNode next = head.next;
        head.next = null;
        if(odd) {
            oddTmp.next = head;
            oddTmp = oddTmp.next;
            odd = false;
        }else {
            evenTmp.next = head;
            evenTmp = evenTmp.next;
            odd = true;
        }
        head = next;
    }
    oddTmp.next = evenHead.next;
    return oddHead.next;
}

24、leetcode445: 两数相加II

题目描述：与leetcode2_两数相加的区别之处在于本题的数字是正序存储，leetcode2的数字是逆序存储。如[1,2,3] 在leetcode2中表示321，在本体表示123.

解题思路：能想到最简单的方式是把链表反转，然后累加在反转链表。如果加限制条件，不能反转链表，官方题解是使用栈存储节点，然后通过头插法得到结果。

private static ListNode problem445_TwoNumSumV2(ListNode p1, ListNode p2) {
    if(p1 == null) return p2;
    if(p2 == null) return p1;
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>(); 
    while(p1 != null) {
        stack1.push(p1.val);
        p1 = p1.next;
    }
    while(p2 != null) {
        stack2.push(p2.val);
        p2 = p2.next;
    }

    ListNode res = new ListNode(-1);
    int carry = 0;
    while(!stack1.isEmpty() || !stack2.isEmpty() || carry > 0) {
        int num1 = stack1.isEmpty() ? 0 : stack1.pop();
        int num2 = stack2.isEmpty() ? 0 : stack2.pop();
        int sum = num1 + num2 + carry;
        carry = sum/10;

        // 头插法插入节点
        ListNode node = new ListNode(sum % 10);
        ListNode next = res.next;
        res.next = node;
        node.next = next;
    }
    return res.next;
}

25、leetcode725: 分隔链表

题目描述：给你一个头结点为 head 的单链表和一个整数 k ，请你设计一个算法将链表分隔为 k 个连续的部分。每部分的长度应该尽可能的相等：任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。这 k 个部分应该按照在链表中出现的顺序排列，并且排在前面的部分的长度应该大于或等于排在后面的长度。

例1: head = [1,2,3], k = 5， 输出： [[1],[2],[3],[],[]]

例2: head = [1,2,3,4,5,6,7,8,9,10], k = 3， 输出： [[1,2,3,4],[5,6,7],[8,9,10]]

解题思路: 

  1. 计算链表长度。
  2. 获取每一个下标最少要的节点数: perNum=len/k。
  3. 获取最后多的节点数: left=len%k；
  4. 遍历链表拆分，每个节点的节点数= perNum + (left > 0 ? 1 : 0);
  5. left--；循环第4步。
public static ListNode[] splitListToParts(ListNode head, int k) {
    ListNode[] res = new ListNode[k];
    if(head == null) return res;
    int len = getListNodeLength(head);
    int perNum = len / k;
    int left = len % k;
    for(int i = 0; i<k; i++) {
        int nodeNum = perNum + (left > 0 ? 1: 0);
        ListNode node = new ListNode(-1), tmp = node;
        for(int j = 0; j<nodeNum && head != null; j++) {
            ListNode next = head.next;
            head.next = null;
            tmp.next = head;
            head = next;
            tmp = tmp.next;
        }
        left--;
        res[i] = node.next;
    }
    return res;
}

public static int getListNodeLength(ListNode head) {
    ListNode tmp = head;
    int len = 0;
    while(tmp != null) {
        len++;
        tmp = tmp.next;    
    }
    return len;
}
玛卡巴卡历险记
关注
  • 21
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言结构体链表的排序方法汇总
12-29
### C语言结构体链表的排序方法：选择排序与插入排序 在计算机科学领域，数据结构与算法的设计是...了解这些排序方法不仅能帮助我们在实际开发中更好地处理数据结构问题，也能加深我们对计算机科学基础知识的理解。
链表的基本操作，包括插入数据和删除数据
10-28
### 链表基本操作：插入与删除 链表是一种常用的数据结构，在计算机科学中扮演着重要的角色。链表由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表的操作主要包括插入和删除等，这些操作是实现更...
Leetcode链表问题汇总
dezhonger的专栏
10-24 281
假设链表存在环，则当第一个指针走到环入口时，第二个指针已经走到环上的某个位置，距离环入口还差 x 步。由于第二个指针每次比第一个指针多走一步，所以第一个指针再走 x步，两个指针就相遇了。用两个指针从头开始扫描，第一个指针每次走一步，第二个指针每次走两步。否则如果两个指针相遇，则说明存在环。比较简单的题目，头结点标示的个位数字，因此直接模拟就可以了。注意链表相关的题目可以添加一个虚拟头节点，用来简化一些边界情况的处理。复杂度分析，由于慢指针走的总步数小于链表总长度，复杂度为。
面试链表问题 汇总
阿豪
10-16 56
原文链接: 面试链表问题 汇总 上一篇: ...
c++链表问题汇总(代码及解析)
祥瑞的技术博客
09-01 1750
目录 一、链表与指针 1.1 单向双向表 1.2 数组指针 1.3 链表的合并 二、链表应用汇总 2.1 链表中的值倒序 2.2 链表的倒数第k个节点 2.3 反转链表 2.4 链表的公共节点 2.5 链表环的入口节点 三、复杂链表的复制 3.1 题干 3.2 思路及注意事项 3.3 正确答案 3.4 错误代码找错 四、二叉树转为双向链表 相应oj链接： htt...
剑指offer | 链表问题汇总
RUC_Lee的博客
08-02 225
链表问题汇总1 前言2 题目题1 链表中倒数第k个结点 1 前言 2 题目 题1 链表中倒数第k个结点 输入一个链表，输出该链表中倒数第k个结点。 思路： 如果输出链表正向的第k个结点会吗？应该会的！那么再得到长度，一减，就ok了啊！ 但是上面思路太麻烦，有一个非常牛逼的思路！ 牛逼思路：我们可以定义两个指针。 第一个指针从链表的头指针开始遍历向前走k-1，第二个指针保持不动； 从第k步开...
常见链表问题（整理）
weixin_53235104的博客
04-19 254
一、数组与链表 作为线性表的两种存储方式 —— 链表和数组，这对相爱相杀的好朋友有着各自的优缺点。接下来，我们梳理一下这两种方式。 数组，所有元素都连续的存储于一段内存中，且每个元素占用的内存大小相同。这使得数组具备了通过下标快速访问数据的能力。但连续存储的缺点也很明显，增加容量，增删元素的成本很高，时间复杂度均为 O(n)。 增加数组容量需要先申请一块新的内存，然后复制原有的元素。如果需要的话，可能还要删除原先的内存。 删除元素时需要移动被删除
链表操作汇总
qq_41729237的博客
09-14 105
文章目录创建新的节点创建链表输出链表在链表中查找某个值 创建新的节点 返回链表头指针并且将节点初始化。 struct node{ int val; node *next; }; node * creatNode(){ node *newNode=new node; newNode->next=NULL; newNode->val=0; return newNode; } 创建链表 输入n个值，创建一个长度为n的链表 node *creatList(int n){ node *he
带环链表相交问题
城南????已开
03-06 792
  带环链表交点完整代码在最后。 1不带环链表相交 1.1问题描述 LeetCode-相交链表：   编写一个程序，找到两个单链表相交的起始节点。   如下面的两个链表：   在节点 c1 开始相交，若两链表不相交，则返回null。   如上图所示（其中abc表示节点的个数），使用两个指针x和y分别指向链表1和链表2的起始位置开始向后遍历：   对于有交点的链表： x指针从链表1开始向后走，当走到链表1的末尾时，其走过了a+c个节点，此时将x指针指向链表2的头部。 y指针从链表2开始向后走，当走到链表
用python构建链表问题详解
weixin_41221502的博客
10-10 824
用python构建链表问题详解、单向链表、双向链表、循环链表的python实现
链表汇总
Dcwjh的博客
05-18 354
先刷题，在总结 文章目录剑指 Offer 06. 从尾到头打印链表剑指 Offer 22. 链表中倒数第k个节点138. 复制带随机指针的链表剑指 Offer 24. 反转链表剑指 Offer 18. 删除链表的节点剑指 Offer 52. 两个链表的第一个公共节点1721. 交换链表中的节点24. 两两交换链表中的节点面试题 02.05. 链表求和725. 分隔链表 剑指 Offer 06. 从尾到头打印链表 方法一：链表从前遍历，数组从尾开始存储 方法二：将链表节点中的值存入栈中，在存入数组中 publ
链表试题算法汇总.doc
10-12
ink() error:%d\n", res);return res;}Link *pPre = NULL;Link *pCurr = pHead;Link *pNext;while (pCurr !...链表因其动态特性，在解决许多实际问题时非常有用，例如在内存管理、数据存储和图形算法等领域。
基础算法与数据结构汇总，包括排序、链表、二叉树、图、暴力递归、贪心算法等相关内容.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 ..."如果问题的最优解包含子问题的最优解，则该问题表现出最优子结构
面试问题汇总
08-04
【标题】：“面试问题汇总”通常意味着这是一份集中的技术面试问题集合，可能涵盖了多个IT领域的关键知识点，包括但不限于编程语言、数据结构、算法、操作系统、计算机网络、数据库、软件工程等方面。这类文档通常...
J031_使用TCP协议支持与多个客户端同时通信
最新发布
lzn20161229的博客
08-03 215
使用TCP协议支持与多个客户端同时通信。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 620
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
m0_74283290的博客
08-03 625
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
社区养老服务小程序的设计
Karen198的博客
07-31 539
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
C++笔试题汇总：链表反转等经典问题解析
"c++笔试题汇总，包含了链表反转等常见面试题目，提供了两种链表反转的实现方式：一种是迭代法，另一种是递归法。同时提到了String类的通用构造函数。" 在C++的笔试题中，链表反转是一个经典的问题，主要考察程序员...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值