单向链表的原地归并排序实现

前段时间准备一些面试题时，才开始考虑链表的排序问题。当时一想就感觉原地归并的实现有戏，上网找了一下，发现有人竟是先将链表打散成数组再来排，非常汗。于是自己写了个非递归的原地归并实现，如下：

 #include <stdlib.h>

template<class T>
struct Node
{
 Node(T d)
 {
  data = d;
  next = NULL;
 }
 T data;
 Node *next;
};

template<class  T>
Node<T> * GetTailNode( Node<T> *startNode, int length )
 //按长度找到尾节点
{
 while(length-- && startNode->next != NULL)
 {
  startNode = startNode->next;
 }
 return startNode;
}

template<class T, class CmpFunc>
Node<T> * Merge( Node<T> *&startNode, int currBlockLen, CmpFunc cmp )
 //从startNode开始，按currBlockLen二分，进行归并操作
{
 bool canMerge = true;
 Node<int> *leftBlock = startNode, *rightBlock = startNode;

 // 找到rightBlock的头节点
 for(int i = 0; i<currBlockLen; ++i)
 {
  rightBlock = rightBlock->next;
  if(rightBlock == NULL)
  {
   canMerge = false;
   break;
  }
 }

 if(!canMerge)
  return NULL;

 Node<int> *currSortedNode;    //排序结果的当前节点
 Node<int> *currTailNode = NULL;  //排序结果的尾节点，用于最后将排序结果与下一段链表数据连接
 int leftCount = 0, rightCount = 0;

 //初始化currSortedNode
 if( cmp(leftBlock->data, rightBlock->data) )
 {
  ++rightCount;
  currSortedNode = startNode = rightBlock;
  rightBlock = rightBlock ->next;
 }
 else
 {
  ++leftCount;
  currSortedNode = leftBlock;
  leftBlock = leftBlock ->next;
 }

 while(true)
 {
  if(leftCount == currBlockLen || leftBlock == NULL )
   //当leftBlock完成排序时，leftBlock尾节点即为currSortedNode
  {
   currSortedNode->next = rightBlock;   //剩下的rightBlock无需再排序，直接加入结果链
   currTailNode = GetTailNode( currSortedNode, currBlockLen-rightCount );   //找到结果的尾节点
   break;
  }
  else if(rightCount == currBlockLen || rightBlock == NULL )
   //当右Block完成排序，此时右Block的尾节点即为currSortedNode
  {
   Node<T> *tmpNode = currSortedNode->next;   //记下下一段链表的头节点

   currSortedNode->next = leftBlock;
   currTailNode = GetTailNode( currSortedNode, currBlockLen-leftCount );
   currTailNode->next = tmpNode;     //将结果链表与下一段链表连起来
   break;
  }
  else
   //普通的归并操作
  {
   if(cmp(leftBlock->data, rightBlock->data))
   {
    ++rightCount;
    currSortedNode->next = rightBlock;
    rightBlock = rightBlock->next;
   }
   else
   {
    ++leftCount;
    currSortedNode->next = leftBlock;
    leftBlock = leftBlock->next;
   }
   currSortedNode = currSortedNode->next;
  }
 }
 return currTailNode->next != NULL ? currTailNode : NULL;    //返回NULL意味着一轮归并的结束
}

template<class T, class CmpFunc>
void MergeSort( Node<T>* &dataLink, CmpFunc cmp )
{
 int currBlockLen = 1;
 Node<T> *lastTailNode;
 while( true )
 {
  lastTailNode = Merge( dataLink, currBlockLen, cmp );
  if(lastTailNode != NULL)
  {
   do
   {
    lastTailNode = Merge( lastTailNode->next, currBlockLen, cmp );
   }
   while ( lastTailNode != NULL );
   currBlockLen *= 2;
  }
  else
   break;
 }
}

对以上实现的测试代码如下：

 Node<int> *BuildLink( int *data, int len )
{
 Node<int> *header = new Node<int>(data[0]);
 Node<int> *currNode = header;
 for(int i = 1; i<len; ++i)
 {
  currNode->next = new Node<int>( data[i] );
  currNode = currNode->next;
 }
 return header;
}

inline bool IntCmp( int &a, int &b )
{
 return a>b;
}

#include <time.h>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main()
{
 srand(time(0));
 int dataLen = 10000;
 int *data = new int[dataLen];
 for(int i = 0; i<dataLen; ++i)
 {
  data[i] = rand();
 }
 Node<int> *link = BuildLink(data,dataLen);
 MergeSort(link, IntCmp);

 while(link != NULL)
 {
  printf("%d ", link->data);
  link = link->next;
 }
}

 

      做了这个实现后，我也问了一些人这样是否是最高效的了，结果一ACM大牛坚持认为快排才是最高效的，认为快排的均摊就是好于原地归并。这个我是不同意的，因为我还没想到单向链表上快排的高效实现（一个交换操作就很够呛了），而且即使实现了，均摊也几乎没可能超过这里的原地归并实现（这里最差就O(nlgn)，系数大不到哪去，就是遍历链表的开销，而快排最优下也是O(nlgn)，遍历的开销同样无法避免）。

      不过我只是一介菜鸟耳，希望听听各位高手的看法。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/sgzwkrm/archive/2009/06/02/4235199.aspx