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

题目

给定一个单向链表的头节点head，节点的值类型是整型，再给定一个 整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot 的节点，中间部分都是值等于pivot的节点，右部分都是值大于 pivot的节点。 除这个要求外，对调整后的节点顺序没有更多的要求。 例如：链表9->0->4->5- >1，pivot=3。 调整后链表可以是1->0->4->9->5，也可以是0->1->9->5->4。总 之，满 足左部分都是小于3的节点，中间部分都是等于3的节点（本例中这个部 分为空），右部分都是大于3的节点即可。对某部分内部的节点顺序不做要求。

思路

先将链表转化为数组，采用荷兰国旗解法对数组按要求排序，然后再转回链表；

代码实现

 public static class ListNode {
        public int value;
        public ListNode next;

        public ListNode(int value) {
            this.value = value;
        }
    }

    public static ListNode listPartition(ListNode head, int k) {
        if (head == null) {
            return head;
        }
        ListNode cur = head;
        int size = 0;
        while (cur != null) {
            size++;
            cur = cur.next;
        }
        int index = 0;
        ListNode[] arr = new ListNode[size];
        while (head != null) {
            arr[index++] = head;
            head = head.next;
        }
        //采用荷兰国旗解法
        arrPartition(arr, k);
        for (int i = 1; i < arr.length; i++) {
            arr[i - 1].next = arr[i];
        }
        arr[index-1].next = null;
        return arr[0];
    }

    private static void arrPartition(ListNode[] arr, int k) {
        int less = -1;
        int more = arr.length;
        int index = 0;
        while (index != more) {
            if (arr[index].value < k) {
                swap(arr, ++less, index++);
            } else if (arr[index].value == k) {
                index++;
            } else {
                swap(arr, --more, index);
            }
        }
    }

    private static void swap(ListNode[] arr, int i, int j) {
        ListNode temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }