java分隔链表

原创已于 2022-09-07 14:01:57 修改 · 310 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #java #数据结构

于 2022-07-18 21:28:55 首次发布

该博客介绍了如何解决LeetCode第86题，即根据特定值x将链表拆分为两部分，一部分包含所有小于x的节点，另一部分包含所有大于等于x的节点。博主分享了两种解决方案，通过创建虚拟头结点，分别构建两个新链表，并断开原链表节点，最后将链表连接。文章中还提供了详细的代码实现和解释，以及调试过程中的问题与解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.2 分隔链表

题目来源：leetcode86题
题设：

解答

创建两个链表（使用虚拟头结点），其中一个链表存放比特定值x小的结点，另一个链表存放比特定值x大的结点，最后将这两个链表相连得到目标链表

package Learn_List;

import java.util.Optional;

/**
 * @author xiaozhu
 * @date 2022年07月17日 14:07                          $
 */
public class LeetCode_86_01 {

    public static void main(String[] args) {

        //1 4 3 2 5 2
        ListNode l = new ListNode(1);
        l.next = new ListNode(4);
        l.next.next = new ListNode(3);
        l.next.next.next = new ListNode(2);
        l.next.next.next.next = new ListNode(5);
        l.next.next.next.next.next = new ListNode(2);
//        l.display(l);
        LeetCode_86_01 test = new LeetCode_86_01();
        ListNode l1 = test.partition(l, 3);
        //display方法是我们自己写的链表的遍历打印方法，为了方便测试程序是否正确，比较简单，这里不多展示
        l1.display(l1);

    }

    

    //1 4 3 2 5 2
    /*
     * 单链表的分解
     * @author xiaozhu
     * @date 2022/7/18 21:00
     * @param head
     * @param x 
     * @return Learn_List.ListNode
     */
    public ListNode partition1(ListNode head, int x) {

        //小于x的虚拟头结点
        ListNode dummy1 = new ListNode(-1);

        //大于等于x的虚拟头结点
        ListNode dummy2 = new ListNode(-1);

        //p1 和 p2 负责生成结果链表
        ListNode p1 = dummy1;
        ListNode p2 = dummy2;

        //用于遍历我们所需要拆分的链表
        ListNode p = head;

        while (Optional.ofNullable(p).isPresent()) {
            
            //比较过程
            if (p.val >= x) {
                //在进行第一次循环的时候，p中还有next
                p2.next = p;
                p2 = p2.next;
            } else {
                p1.next = p;
                p1 = p1.next;
            }

            //断开原链表中每个结点的next指针，目的是每次向新的链表中添加新的结点没有next
            //详细过程请看下图的debug过程
            ListNode temp = p.next;
            p.next = null;
            p = temp;

        }
        //连接两个被拆分的链表
        p1.next = dummy2.next;
        return dummy1.next;
    }
    
    /*
     * 单链表的分解
     * @author xiaozhu
     * @date 2022/7/17 14:55
     * @param head
     * @param x 
     * @return Learn_List.ListNode
     */
    public ListNode partition(ListNode head, int x) {

        //小于x的虚拟头结点
        ListNode dummy1 = new ListNode(-1);

        //大于等于x的虚拟头结点
        ListNode dummy2 = new ListNode(-1);


        //p1 和 p2 用于新链表的生成
        ListNode p1 = dummy1;
        ListNode p2 = dummy2;
        //p用于待分解链表的遍历
        ListNode p = head;

        while (Optional.ofNullable(p).isPresent()) {
            if (p.val >= x) {
                p2.next = p;
                p2 = p2.next;
            } else {
                p1.next = p;
                p1 = p1.next;
            }

            ListNode temp = p.next;
            p.next = null;
            p = temp;
        }

        p1.next = dummy2.next;

        return dummy1.next;

    }

}

我们在94行打上断点

我们可以看到在第一次循环的时候直接将整条链表连接到了虚拟头结点为dummy1的链表上，这不是我们所期望的，因此我们必须将val为1的结点与其后继断开

使用断开算法后

            ListNode temp = p.next;
            p.next = null;
            p = temp;

此时我们的目的达到，只将val为1且其后继指针为null的结点连接到虚拟头结点为dummy1的链表上

如有错误和冒犯，欢迎指正