单向链表归并排序

//利用归并排序的思想进行链表排序

//因为数组的归并排序，只有判断大小和赋值给一个新的数组

//这个很适合链表，并且不用申请新的节点。

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

#define NSIZ 1000

typedef struct Node_
{ 

    int m_nvalue; 

    Node_ * next;
}Node; 

//尾插法创建链表
Node * CreateList(int arr[], int n)
{
	Node * head = 0, *p = 0;
	int i = 1;

	head = new Node();
	head->m_nvalue = arr[0];
	p = head;

	for(;i < n; ++i)
	{
		Node * tmp = new Node;
		tmp->m_nvalue = arr[i];
		p->next = tmp;
		p = tmp;
	}
	p->next = 0;

	return head;
}

Node * merge(Node *left, Node * right)
{
	Node * head = 0, * p = 0;

	while(left && right)
	{
		if(left->m_nvalue < right->m_nvalue)
		{
			if(head == 0)
			{
				head = left;
				p = head;
			}
			else
			{
				p->next = left;
				p = left;
			}
			left = left->next;
		}
		else
		{
			if(head == 0)
			{
				head = right;
				p = head;
			}
			else
			{
				p->next = right;
				p = right;
			}
			right = right->next;
		}
	}

	p->next = (left == 0)?right:left;

	return head;
}

//归并排序法排序链表
Node * m_sort(Node * head, int len)
{
	if (len == 0)
	{
		return 0;
	}

	if(len == 1)
	{
		head->next = 0;
		return head;
	}

	Node* pmid = head;
	int half = len / 2 ;
	for(int i = 0;i < half; ++i)
	{
		pmid = pmid->next;
	}

	Node * left = m_sort(head, half );
	Node * right = m_sort(pmid, len - half);

	return merge(left, right);
	
}

//获得链表长度
int GetListLen(Node * head)
{
	if(!head)
	{
		return 0;
	}
	Node * p = head;
	int len = 0;
	while(p)
	{
		p = p->next;
		len++;
	}

	return len;
}

//打印链表
void dump(Node * head)
{
	if(!head)
	{
		return;
	}

	Node *p = head;
	while(p)
	{
		printf("%d ", p->m_nvalue);
		p = p->next;
	}
	printf("\n");
}

int main()
{
	int arr[] = {1, 5, 4, 6, 9, 3};
	int an = sizeof(arr)/sizeof(arr[0]);
	Node * head1 = CreateList(arr, an);

	int Len = GetListLen(head1);
	Node * sortHead = m_sort(head1 , Len);
	dump(sortHead);
	return 0;
}