归并排序：数组和单链表实现

1. 数组的归并排序

// 归并排序的递归调用
void mergeSort(int* A, int beg, int end, int* B)
{
	if ( beg >= end )
	{
		return;
	}
	int mid = (beg + end ) / 2;
	mergeSort( A, beg, mid, B);
	mergeSort( A, mid+1, end, B);
	Merge(A, beg, mid, end, B);
}

// 归并算法实现
void Merge(int* A, int beg, int mid, int end, int* B)
{
	int iLeft = beg;
	int iRight = mid + 1;
	int i = beg;
	while ( iLeft <= mid && iRight <= end )
	{
		if ( A[iLeft] < A[iRight] )
		{
			B[i++] = A[iLeft++];
		}
		else
		{
			B[i++] = A[iRight++];
		}
	}
	while ( iLeft <= mid )
	{
		B[i++] = A[iLeft++];
	}
	while ( iRight <= end )
	{
		B[i++] = A[iRight++];
	}

	for ( int i = beg; i <= end; ++i )
	{
		A[i] = B[i];
	}
}

// 归并排序驱动程序
void MergeSort(int* A, int Len)
{
	int* B = (int*) malloc(sizeof(int) * Len);
	mergeSort( A, 0, Len-1, B);
	free(B);
}

2. 单链表的归并排序

// 归并算法 
void mergeList(LxListPt head, LxListPt mid, LxListPt tail, LxListPt mHead)
{
	LxListPt leftPos = head;
	LxListPt rightPos = mid;
	LxListPt q = mHead;
	while (leftPos != mid && rightPos != tail)
	{
		if (leftPos->data < rightPos->data)
		{
			q->data = leftPos->data;
			q = q->next;
			leftPos = leftPos->next;
		}
		else
		{
			q->data = rightPos->data;
			q = q->next;
			rightPos = rightPos->next;
		}
	}
	while (leftPos != mid)
	{
		q->data = leftPos->data;
		q = q->next;
		leftPos = leftPos->next;
	}
	while(rightPos != tail)
	{
		q->data = rightPos->data;
		q = q->next;
		rightPos = rightPos->next;
	}

	LxListPt p = head;
	q = mHead;

	while( p!= tail)
	{
		p->data = q->data;
		p = p->next;
		q = q->next;
	}
}

//  单链表归并排序递归调用
void mergeSortList(LxListPt head, LxListPt tail, LxList mHead, LxList mTail, int Len)
{
	if ( Len == 1 )
		return;
	int leftLen = Len / 2;
	int rightLen = Len - leftLen;
	LxListPt mid = head;
	LxListPt mMid = mHead;
	for ( int i = 0; i < leftLen; ++i )
	{
		mid = mid->next;
		mMid = mMid->next;
	}
	mergeSortList(head, mid, mHead, mMid, leftLen);
	mergeSortList(mid, tail, mMid, mTail, rightLen);
	mergeList(head, mid, tail, mHead);
}

// 不带头结点单链表归并排序驱动程序
void MergeSortList(LxList L)
{
	int len = ListLength(L);
	LxList mList = NewList(len, 0);
	mergeSortList( L, NULL, mList, NULL, len);
	FreeList(mList);
}

单链表定义：

typedef struct LxListNode
{
	int data;
	struct LxListNode* next;
}LxListNode, *LxListPt, *LxList;

LxList NewNode(int data)
{
	LxListNode* node = (LxListNode*)malloc(sizeof(LxListNode));
	node->data = data;
	node->next = NULL;
	return node;
}

LxList NewList( int len, int data)
{
	LxList ret = NewNode(data);
	LxListPt cur = ret;
	for ( int i = 1; i < len; ++i )
	{
		cur->next = NewNode(data);
		cur = cur->next;
	}
	return ret;
}

int ListLength(LxList L)
{
	int ret = 0;
	while( L != NULL )
	{
		L = L->next;
		++ret;
	}
	return ret;
}

void FreeList(LxList L)
{
	LxListPt p;
	while( L )
	{
		p = L;
		L = L->next;
		free(p);
	}
}