算法学习10：将单向链表按某值划分为左边小、中间相等、右边大的形式

题目

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

分析

根据题目可得，与之前的快排原型荷兰国旗问题十分相似。但是原问题的数据是在数组中，目前的数据在单链表中，需要我们将数据（就是节点）从单链表转移到数组中，完成要求后，再将数组中的内容转移到单链表中。

代码

一、 生成链表添加元素
链表结构体定义，由数据域和指针域构成

typedef struct ListNode{
	int val;
	ListNode *Next;
}*List;

生成头结点，头结点须指向空

List MakeEmpty(){
	List head =(List)malloc(sizeof(ListNode));
	head->next=NULL;
	return head;
}

尾插法

void insert (List head,int num){
	List p=(List)malloc(sizeof(ListNode));
	p->val=num;
	p->next=NULL;
	List r=head;
	while(r->next!=NULL){
		r=r->next;
}
	r->next=p;
}

将链表放入数组中
使用vector容器

vector<int> list_to_arr(List head){
	head=head->next;
	vector<int> arr;
	while(head->next!=NULL){
		arr.push_back(head->val);
}
	return arr;
}

荷兰国旗问题

void partition (vector<int> &arr,int num){
	int cur=0;
	int x=-1;
	int y=arr.size();
	while(cur<y){
		if(arr[cur]<num){
			swap(arr[++x],arr[cur++]);
		}
		else if(arr[cur]==num){
		cur++;
		}else{
		swap(arr[cur++],arr[--y]);
		}
}
}

把数组变为单链表

void arr_to_List(vector<int>arr,List head){
	List cur=head->next;
	vector<int>::iterator beg=arr.begin();
	vector<int>::iterator end=arr.end();
	while(beg!=end){
		cur->val=(*beg++);
		cur=cur->next;
}
}

完整代码

#include<iostream>
#include<vector>
using namespace std;

typedef struct ListNode
{
	int val;
	ListNode *next;
}*List;

void arr_to_list(vector<int>arr,List head)
{
	List cur = head->next;
	vector<int>::iterator beg = arr.begin();
	vector<int>::iterator end = arr.end();
	while(beg != end)
	{
		cur->val = (*beg++);
		cur = cur->next;
	}
}

vector<int> list_to_arr(List head)
{
	head = head->next;//跳过头节点从第一个数开始
	vector<int> arr;
	while(head!=NULL)
	{
		arr.push_back(head->val);
		head = head->next;
	}
	return arr;
}

void insert(List head, int num)
{
	//生成新的节点
	List p = (List)malloc(sizeof(ListNode));
	p->val = num;
	p->next = NULL;
	//遍历找到链表最后的位置
	List r = head;
	while(r->next != NULL)
	{
		r = r->next;
	}
	//新节点加入链表，连在末尾处
	r->next = p;	
}

List MakeEmpty()
{
	List head = (List)malloc(sizeof(ListNode));
	head->next = NULL;
	return head;
}

void sort(vector<int> &arr,int num)
{
	int cur = 0;
	int x = -1;
	int y = arr.size();
	while(cur < y)
	{
		if(arr[cur] < num)
		{
			swap(arr[cur++],arr[++x]);
		}
		else if(arr[cur] == num)
		{
			cur++;
		}
		else
		{
			swap(arr[cur],arr[--y]);
		}
	}
}

int main()
{
	//初始化
	List head = MakeEmpty();
	insert(head,9);
	insert(head,0);
	insert(head,4);
	insert(head,5);
	insert(head,1);

	vector<int> arr = list_to_arr(head);
	int num = 3;
	sort(arr,num);
	arr_to_list(arr,head);

	system("pause");
	return 0;
}

进阶

在实现原问题功能的基础上增加如下要求
【要求】调整后，三块区域的相对顺序与调整前一致。时间复杂度O(N),额外空间复杂度O(1)

分析

创建三块区域，用三个链表表示，每个链表头尾都有一个标志位。再创建一个遍历指针，遍历链表，与给的数比较大小后，将链表中的数放到指定位置连接起来。
当这个区域第一次添加节点，将头与尾标志位都指向这个节点。当添加第二个节点的时候，将该区域尾结点标志位的节点指针域指向这个新节点，并将当前区域的尾结点标志位更新到当前节点。
首先判断节点区域

List sH=null;
List sT=null;
List eH=null;
List eT=null;
List bH=null;
List bT=null;
List next=null;

While(head!=null){
	next=head->next;
	if(head->val<num){
		if(sH=null){
			sH=head;
			sT=head;
		}else{
			sT->next=head;
			sT=head;
		}
	}else if(head->val==num)//其余部分省略
	head=next;
}

将三块区域连接起来，若三个链表都有节点，那么只需将三部分按序连接即可。
先判断小于区域是否存在
若小于区域存在，则链表的头为sH。再判断等于区域是否存在，若存在，将sT指向eH，再将eT指向bH。若等于区域不存在，则将sT指向bH。
若小于区域不存在，则判断等于区域是否存在，若等于区域存在 链表的头为eH。若等于区域不存在链表的头为bH。
代码

List res=null;
if(sH!=null){
	if(eH!=null){
		sT->next=eH;
		eT->next=bH;
	}else{
		sT->next=bH;
	}	
}else{
	if(eH!=null){
		res=eH;
		eT->next=bH;
	}
	else
		res=bT;
}
return res;