双向链表的排序

///双向链表排序,思路是: 把之前的链表依次检索出最小到放到新的链表的尾部,然后指向新的链表,就是来回倒弄指针.
#include <stdio.h>
#include <malloc.h>


typedef struct _BiNode
{
   int data;


   struct _BiNode *Next;
   struct _BiNode *Prev;
}BiNode;


BiNode *CreateBiList(int num)
{
   BiNode *ListHead;
   BiNode *ListCurr;
   BiNode *ListPrev;
   int i;
   if(num==0) return NULL;


   ListHead=(BiNode *)malloc(sizeof(BiNode));
   if(ListHead==NULL) return NULL;


   ListHead->data=0;
   ListHead->Next=NULL;
   ListHead->Prev=NULL;


   ListPrev=ListHead;
  
  for(i=1;i<num;i+=2)
  {
           ListCurr=(BiNode *)malloc(sizeof(BiNode));
           if(ListCurr==NULL) return ListHead;
           
  ListCurr->data=i;
  ListCurr->Prev=ListPrev;
  ListCurr->Next=NULL;


           ListPrev->Next=ListCurr;
  ListPrev=ListCurr;
   }
  for(i=2;i<num;i+=2)
  {
           ListCurr=(BiNode *)malloc(sizeof(BiNode));
           if(ListCurr==NULL) return ListHead;
           
  ListCurr->data=i;
  ListCurr->Prev=ListPrev;
  ListCurr->Next=NULL;


           ListPrev->Next=ListCurr;
  ListPrev=ListCurr;
   }


  return ListHead;
}


int printBiList(BiNode *BiList)
{
    BiNode *tmpList=BiList;
    int cnt=0;
if(BiList==NULL) return -1;


while(tmpList!=NULL)
     {
   printf("No %d BiNode is %d\n",cnt++,tmpList->data);
tmpList=tmpList->Next;
}
return 0;
}
BiNode *FindMinNode(BiNode *list)
{
BiNode *tmpNode;
BiNode *MinNode=NULL;


    if(list==NULL) return NULL;


MinNode=list;
    tmpNode=list->Next;
while(tmpNode!=NULL)
    {
 if(MinNode->data>tmpNode->data)
 {
 MinNode=tmpNode;
 }
 tmpNode=tmpNode->Next;
}
return MinNode;
}
int sortMin(BiNode *List)
{
     BiNode *NewList;
     BiNode *OldList;
     BiNode *MinNode;
     BiNode *NodePrev;


OldList=List;
     MinNode=FindMinNode(OldList);
if(MinNode==NULL)  return 0;


     if(MinNode->Next)
{
MinNode->Next->Prev=MinNode->Prev;    
     }
     if(MinNode->Prev)     
{
MinNode->Prev->Next=MinNode->Next;  
}
else
        OldList=MinNode->Next;///关键是这里,要把抽出来后的链表跳变


     MinNode->Next=NULL;
     MinNode->Prev=NULL;
     NewList=MinNode;
NodePrev=NewList;


while(OldList!=NULL) xxxxx
     {
      MinNode=FindMinNode(OldList);
      if(MinNode==NULL)  
  {  
  List= NewList; 
  return 0;
  }
  if(MinNode->Next)
  {
       MinNode->Next->Prev=MinNode->Prev;   
            }
            if(MinNode->Prev)     
{
        MinNode->Prev->Next=MinNode->Next;        
}
       else
               OldList=MinNode->Next; 

MinNode->Prev=NodePrev;
            MinNode->Next=NULL;    
NodePrev->Next=MinNode;  


NodePrev=MinNode;
}

    List= NewList; 
return 0;
}


int main()
{
   BiNode *BiList;


BiList=CreateBiList(20);


printBiList(BiList);


printf("-------------------sort after---------------------\n");


sortMin(BiList);
    printBiList(BiList);
}