单链表排序

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

typedef struct Node
{
	int val;
	Node* next;

}*pNode;

void print_list(pNode head)
{
	pNode tmp = head;
	while(tmp)
	{
		std::cout<<tmp->val<<" ";
		tmp = tmp->next;
	}
	std::cout<<std::endl;
}

void insert_list(pNode& head, int* arr, int len)
{
	pNode tmp = head;
	if(NULL == head)
	{
		head = new Node;
		head->val = 1000;
		head->next = NULL;
		tmp = head;
	}
	else
	{
		while(tmp->next)
		{
			tmp = tmp->next;
		}
	}

	for(int index = 0x00; index < len; index++)
	{
		pNode node = new Node;
		node->val = arr[index];
		tmp->next = node;
		node->next = NULL;
		tmp = node;
	}
}

void destroy_list(pNode& head)
{
	pNode tmp = head;
	while(tmp)
	{
		pNode p = tmp->next;
		delete tmp;
		tmp = p;
	}

}

void sort_list(pNode& head)
{
	if(!head || head->next == NULL)
		return ;

	pNode pre = NULL;
	pNode back = NULL;

	pNode newNode = NULL;
	pNode newBkNode = NULL;
	bool flag = false;
	while(!flag)
	{
		//最小队列
		pNode minNode = head;
		pNode minNodePre = head;

		//最大队列
		pNode maxNode = head;
		pNode maxNodePre = head;

		//遍历当前队列，找到最小和最大的节点
		pNode tmp = head;
		pNode tmp_pre = head;

		while(tmp)
		{
			//查找最小节点
			if(minNode->val >= tmp->val)
			{
				minNode = tmp;
				minNodePre = tmp_pre;
			}

			//查找最大节点
			if(maxNode->val <= tmp->val)
			{
				maxNode = tmp;
				maxNodePre = tmp_pre;
			}
			tmp_pre = tmp;
			tmp = tmp->next;
		}
		
		if(minNode == NULL || maxNode == NULL)
			break;

		//打印本次查找到的最大/最小节点数值
		if(maxNode && minNode)
		{
			std::cout<<"max = "<<maxNode->val<<", min:"<<minNode->val<<std::endl;
		}

		//如果最大最小节点不为同一个
		if(minNode != maxNode)
		{
			if(minNode != minNodePre)
			{
				minNodePre->next = minNode->next;
				minNode->next = NULL;
			}
			else//当前队列头为最小节点
			{
				head = minNode->next;
				minNode->next = NULL;
			}

			if(maxNode != maxNodePre)
			{
				maxNodePre->next = maxNode->next;
				maxNode->next = NULL;
			}
			else//当前队列头为最大节点
			{
				head = maxNode->next;
				maxNode->next = NULL;
			}
		}
		else//最大最小节点为同一个，排序查找结束
		{
			maxNode = NULL;
			flag = true;
		}

		if(newNode == NULL )//最小队列第一个元素
		{
			newNode = minNode;
			newNode->next = NULL;
			pre = newNode;
		}
		else//依次插入到最小队列后面
		{
			while(pre->next) 
				pre = pre->next;
			pre->next = minNode;
			pre = minNode;
		}

		if(newBkNode == NULL)//初始化最大队列
		{
			newBkNode = maxNode;
			newBkNode->next = NULL;
		}
		else if(maxNode)//依次插入到最大队列前面
		{
			maxNode->next = newBkNode;
			newBkNode = maxNode;
		}  

	}

	if(pre)//两个队列合并
		pre->next = newBkNode;

	//指定队列头
	head = newNode;
}
int main()
{
	const int arr_size = 1000;
	pNode head = NULL;

	int arr[arr_size] = {0x00};
	for(int index = 0x00; index < arr_size; index++)
		arr[index] = index%10+0x01;

	insert_list(head, arr,arr_size);
	print_list(head);
	sort_list(head);
	print_list(head);
	destroy_list(head);
	return 0x00;
}