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

题目：给定一个单向链表的头结点head,节点的值类型是整型，再给定一个整数privot。实现一个调整链表的函数，将链表调整为左部分都是值小于privot的节点，中间部分都是值等于privot的节点，右部分都是大于privot的节点。

例如:链表9-0-4-5-1，pivot=3。

调整后是1-0-4-9-5，也可以是0-1-9-5-4。

解法1：我们可以利用数组额外空间来实现：

1。先遍历一遍链表，得到链表长度。

2。建立一个链表数组。

3。利用三向快排的划分

4。调整数组中的next值。

代码如下：

class Node{
public int value;
public Node next;
public Node(int data){
this.value=data;
}
}
public class quicklist {
public Node listPartition1(Node head,int privot){
if (head==null){
return head;
}
Node cur=head;
int i=0;
//先遍历一遍获得链表的
while(cur!=null){
i++;
cur=cur.next;
}
Node[] nodeArr=new Node[i];
i=0;
cur=head;
for (i = 0; i !=nodeArr.length ; i++) {
nodeArr[i]=cur;
cur=cur.next;
}
//调整在数组中的顺序
arrPartion(nodeArr,privot);
//调整赋值
for (i = 0; i != nodeArr.length; i++) {
nodeArr[i-1].next=nodeArr[i];//
}
nodeArr[i-1].next=null;
return nodeArr[0];
}

/**
* 三向切分快排一趟交换，需要三个记录量
* @param nodeArr
* @param privot
*/
private void arrPartion(Node[] nodeArr, int privot) {
int small=-1;
int big=nodeArr.length;
int index=0;
while (index!=big){
if (nodeArr[index].value<privot){
swap(nodeArr,++small,index++);
}else if (nodeArr[index].value==privot){
index++;
}else {
swap(nodeArr,--big,index);
}
}
}

private void swap(Node[] nodeArr, int i, int j) {
Node tmp=nodeArr[i];
nodeArr[i]=nodeArr[j];
nodeArr[j]=tmp;
}
}

解法二：不需要额外空间复杂度的情况下完成调整：

1。将原链表中的所有节点一次划分进三个链表，三个链表分别为small代表左部分，equal代表中间部分，big代表右部分。

例如，链表7-9-1-8-5-2-5，privot=5。在划分之后,small,equal,big分别为:

small:1-2-null

equal:5-5-null

big:7-9-8-null

2。重新串联

3。需要重点判断null。

具体代码这里不予列出。。