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

package com.my.util;
/**
 * 单向链表节点
 * */
public class SingleNode {
	public int value;
	public SingleNode next;
	public SingleNode(int data){
		this.value = data;
	}
}

package com.my.suanfa;

import com.my.util.SingleNode;

/**
 * 将单向链表按某值划分成左边小，中间相等，右边大的形式
 * */
public class Solution05 {
		/**
		 * 方法1：时间复杂度为O(N),额外空间复杂度为O(N)
		 * 					对以上三部分内部链表的次序无要求
		 * */
	public SingleNode listPatition1(SingleNode head, int pivot) {
		//边界条件判断
		if(head == null) {
			return head;
		}
		//遍历链表计算链表的总节点数
		SingleNode cur = head;
		int i = 0;
		while(cur != null) {
			i++;
			cur = cur.next;
		}
		//创建一个数组，并将链表中元素依次放入数组中
		SingleNode[] nodeArr = new SingleNode[i];
		i = 0;
		cur = head;
		for(i = 0; i < nodeArr.length; i++) {
			nodeArr[i] = cur;
			cur = cur.next;
		}
		//对数组中节点的顺序进行调整
		arrPartition(nodeArr, pivot);
		/**
		 * 将数组中的节点从头到尾重新连接成单链表
		 * */
		for(i = 1; i < nodeArr.length; i++) {
			nodeArr[i - 1].next = nodeArr[i];
		}
		//此时i == nodeArr.length,退出循环，将最后一个节点的后继节点设为空
		nodeArr[i - 1].next = null;
		//数组中的第一个节点就是新链表的头结点
		return nodeArr[0];
	}
	
	/*
	 * 调整数组中节点的顺序
	 * */
	public void arrPartition(SingleNode[] nodeArr, int pivot) {
		int small = -1;
		int big = nodeArr.length;
		int index = 0;
		while(index != big) {
			if(nodeArr[index].value < pivot) {
				//因为small下标所对应的值都在index所对应的值得左边，都已经判断过了，所以交换之后不必再次判断，因此index++
				swap(nodeArr, ++small, index++);
			} else if(nodeArr[index].value == pivot) {
				index++;
			}else {
				//因为big下标所对应的值都在index所对应的值得右边，都没有判断，因此交换位置之后，index所对应的值还没有判断，因此index不能改变
				swap(nodeArr, --big, index);
			}
		}
	}
	
	/**
	 * 调换两个节点的位置
	 * */
	public void swap(SingleNode[] nodeArr, int a, int b) {
		SingleNode tmp = nodeArr[a];
		nodeArr[a] = nodeArr[b];
		nodeArr[b] = tmp;
	}
	
	/**
	 * 方法二：时间复杂度为O(N),额外空间复杂度为O(1)，只使用有限的几个变量完成链表的调整过程
	 * 					对以上三部分内部链表的次序有要求，要求调整后的各部分内部次序与原链表一致，即要求稳定性
	 * */
	public SingleNode listPartition2(SingleNode head, int pivot) {
		//将原链表划分为三个子链表，定义有限变量来记录链表的不同位置
		SingleNode sH = null;	//小的头
		SingleNode sT = null;	//小的尾
		SingleNode eH = null;	//相等的头
		SingleNode eT = null;	//相等的尾
		SingleNode bH = null;	//大的头
		SingleNode bT = null;	//大的尾
		SingleNode next = null;	//记录下一个节点
		//将原链表分割成三个子链表
		while(head != null) {
			next = head.next;
			//将head的后继节点设为空，否则后面分开存放可能会将其后继节点也存入
			head.next = null;
			if(head.value < pivot) {
				if(sH == null) {
					sH = head;
					sT = head;
				} else {
					sT.next = head;
					sT = head;
				}
			} else if(head.value == pivot) {
				if(eH == null) {
					eH = head;
					eT = head;
				}else {
					eT.next = head;
					eT = head;
				} 
			} else {
				if(bH == null) {
					bH = head;
					bT = head;
				} else {
					bT.next = head;
					bT = head;
				}
			}
			head = next;
		}
		
		//将小的部分和相等的部分连接起来
		if(sT != null) {
			sT.next = eH;
			eT = eT == null ? sT : eT;
		}
		//全部连接起来
		if(eT != null) {
			eT.next = bH;
		}
		//返回连接之后的头结点，如果小的头不为空返回小的头，否则看相等的头，如果相等的头不为空，返回相等的头，否则返回大的头
		return sH != null ? sH : eH != null ? eH : bH;
	}
}