标签：listNode 单向 某值 next 链表 eT ListNode null

将单向链表按某值划分成左边小、中间相等、右边大的形式

【题目】给定一个单链表的头节点head，节点
数pivot。实现一个调整链表的函数，将徙衣笈~'i力匀ivot的节点。节点，中间部分都是值等于pivot的节点，右部分都是值大于pivot的节点。
【进阶】在实现原问题功能的基础上增加如下的要求
【要求】调整后所有小于pivot的节点之间的相对顺序和调整前一样【要求】调整后所有等于pivot的节点之间的相对顺序和调整前一样【要求】调整后所有大于pivot的节点之间的相对顺序和调整前一样【要求】时间复杂度请达到0(N)，额外空间复杂度请达到0(1)。

思想

1. 准备六个结点，分别是小于链表的链首和尾，等于链表的首尾以及大于链表的首尾
2. 遍历传入的链表，将每一个元素与目标值做比较，如果小于目标值则尾插入小于链表的链尾，等于则尾插入等于链表的链尾，大于等尾插入大于链表的链尾
3. 最后依次将小于链表的链尾，等于链表的链首以及大于链表的链首相连（如果三个链表都不为空）。当其中有一个或两个链表为空，则不连接该链表

性能

时间复杂度为O（n）
空间复杂度为O（1）
性能稳定

代码

package ListNode;

import Pojo.ListNode;

public class ListNode_partition {

    public static void main(String[] args) {
        int arr[] = {10, 5, 6, 8,  8, 6, 5, 10};
        Huiwen my = new Huiwen();

        ListNode node = null;
        ListNode firstNode = null;
        // 采用头插法建立单链表
        for (int i =0; i < arr.length; i++)
        {
            ListNode listNode = new ListNode(arr[i]);
            if (node == null)
            {
                node = listNode;
                firstNode = node;
            }
            else
            {
                node.next = listNode;
                node = listNode;

            }
            System.out.print(node.data + ", ");
        }
        System.out.println();
        ListNode listNode = listPartition(firstNode, 8);
        //System.out.println(listNode == null);
        while (listNode != null)
        {
            System.out.print(listNode.data + ", ");
            listNode = listNode.next;
        }
    }

    public static ListNode listPartition(ListNode listNode, int pivot)
    {
        ListNode sH = null;
        ListNode sT = null;
        ListNode eH = null;
        ListNode eT = null;
        ListNode gH = null;
        ListNode gT = null;

        while (listNode != null)
        {
            ListNode next = listNode.next;

            listNode.next = null;// 不可少，这是为了使其成为一个独立的结点，不指向其他的结点，以方便加入其他链表

            // 如果当前结点的值小于目标值，则加入 小于链表的链尾
            if (listNode.data < pivot)
            {
                // 第一次加入时，链表为空，头尾都指向第一个结点
                if (sH == null)
                {
                    sH = listNode;
                    sT = listNode;
                }
                else
                {
                    sT.next = listNode;
                    sT = listNode;
                }
            }
            // 如果当前结点的值等于目标值，则加入 等于 链表的链尾
            else if (listNode.data == pivot)
            {
                if (eH == null)
                {
                    eH = listNode;
                    eT = listNode;
                }
                else
                {
                    eT.next = listNode;
                    eT = listNode;
                }
            }
            // 如果当前结点的值大于目标值，则加入 大于链表的链尾
            else
            {
                if (gH == null)
                {
                    gH = listNode;
                    gT = listNode;
                }
                else
                {
                    gT.next = listNode;
                    gT = listNode;
                }
            }
            listNode = next;
        }

        // 因为序列的数值分布状况不同，可能遍历下来，只存在大于链表，也可能存在小于链表和大于链表，因此需要做出相应的判断
        
        // small and equal reconnect
        // 如果小于区域存在，将小于区域的尾结点的next指向等于区域的头部，
        if (sT != null)
        {
            sT.next = eH;
            eT = eH == null ? sT : eT; // 决定由哪个区域的链尾去链接大于区域的头
        }
        // 不管上面这个if有没有执行，eT都需要被判断
        if (eT != null) // 如果小于区域不是都没有
            eT.next = gH;

        // 如果小于区域存在，返回小于区域的链首，不存在则返回等于区域的链首，还不存在则返回大于区域的链首部
        return sH != null ? sH : (eH != null ? eH : gH);
    }
}

标签：listNode,单向,某值,next,链表,eT,ListNode,null
来源： https://blog.csdn.net/yxg520s/article/details/122759572

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。