单链表的排序

链表的排序  

 

==========================
 功能：选择排序(由小到大)
 返回：指向链表表头的指针
==========================
*/

/*
 选择排序的基本思想就是反复从还未排好序的那些节点中，
 选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点，
 依次重新组合成一个链表。

 我认为写链表这类程序，关键是理解：
 head存储的是第一个节点的地址，head->next存储的是第二个节点的地址；
 任意一个节点p的地址，只能通过它前一个节点的next来求得。

单向链表的选择排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head   1->next  3->next  2->next   n->next

---->[NULL]（空链表）
first
tail

---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
first   1->next  2->next  3->next   tail->next

图10：有N个节点的链表选择排序

1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中；
2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；
3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针；
*/
struct student *SelectSort(struct student *head)
{
 struct student *first; /*排列后有序链的表头指针*/
 struct student *tail; /*排列后有序链的表尾指针*/
 struct student *p_min; /*保留键值更小的节点的前驱节点的指针*/
 struct student *min; /*存储最小节点*/
 struct student *p; /*当前比较的节点*/
 
 first = NULL;
 while (head != NULL) /*在链表中找键值最小的节点。*/
 {
  /*注意：这里for语句就是体现选择排序思想的地方*/
  for (p=head,min=head; p->next!=NULL; p=p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
  {  
   if (p->next->num < min->num) /*找到一个比当前min小的节点。*/
   {
    p_min = p; /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/
    min = p->next; /*保存键值更小的节点。*/
   }
  }
 
  /*上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表。*/
 
  /*第一件事*/
  if (first == NULL) /*如果有序链表目前还是一个空链表*/
  {
   first = min; /*第一次找到键值最小的节点。*/
   tail = min; /*注意：尾指针让它指向最后的一个节点。*/
  }
  else /*有序链表中已经有节点*/
  {
   tail->next = min; /*把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
   tail = min; /*尾指针也要指向它。*/
  } 

  /*第二件事*/
  if (min == head) /*如果找到的最小节点就是第一个节点*/
  {
   head = head->next; /*显然让head指向原head->next,即第二个节点，就OK*/
  }
  else /*如果不是第一个节点*/
  {
   p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
  } 
 }

 if (first != NULL) /*循环结束得到有序链表first*/
 {
  tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/
 }
 head = first;
 return head;
}

/*
==========================
 功能：直接插入排序(由小到大)
 返回：指向链表表头的指针
==========================
*/

/*
 直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值
 （就是用它排序的字段，我们取学号num为键值）排好序的，对于节点n在
 这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次
 对链表从头到尾执行一遍，就可以使无序链表变为有序链表。
 
单向链表的直接插入排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head   1->next  3->next  2->next   n->next

---->[1]---->[NULL]（从原链表中取第1个节点作为只有一个节点的有序链表）
head
图11

---->[3]---->[2]...---->[n]---->[NULL]（原链表剩下用于直接插入排序的节点）
first   3->next  2->next   n->next
图12

---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head   1->next  2->next  3->next   n->next

图13：有N个节点的链表直接插入排序

1、先在原链表中以第一个节点为一个有序链表，其余节点为待定节点。
2、从图12链表中取节点，到图11链表中定位插入。
3、上面图示虽说画了两条链表，其实只有一条链表。在排序中，实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。
   这一点请读者务必搞清楚，要不然就可能认为它和上面的选择排序法一样了。
*/
struct student *InsertSort(struct student *head)
{
 struct student *first; /*为原链表剩下用于直接插入排序的节点头指针*/
 struct student *t; /*临时指针变量：插入节点*/
 struct student *p; /*临时指针变量*/
 struct student *q; /*临时指针变量*/
 
 first = head->next; /*原链表剩下用于直接插入排序的节点链表：可根据图12来理解。*/
 head->next = NULL; /*只含有一个节点的链表的有序链表：可根据图11来理解。*/

 while (first != NULL) /*遍历剩下无序的链表*/
 {
  /*注意：这里for语句就是体现直接插入排序思想的地方*/
  for (t=first, q=head; ((q!=NULL) && (q->num < t->num)); p=q, q=q->next); /*无序节点在有序链表中找插入的位置*/
 
  /*退出for循环，就是找到了插入的位置*/
  /*注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能。原因：你若理解了上面的第3条，就知道了。*/
  first = first->next; /*无序链表中的节点离开，以便它插入到有序链表中。*/
 
  if (q == head) /*插在第一个节点之前*/
  {
   head = t;   
  }
  else /*p是q的前驱*/
  {
   p->next = t;  
  }
  t->next = q; /*完成插入动作*/
  /*first = first->next;*/
 }
 return head;
}

/*
==========================
 功能：冒泡排序(由小到大)
 返回：指向链表表头的指针
==========================
*/

/*
 直接插入排序的基本思想就是对当前还未排好序的范围内的全部节点，
 自上而下对相邻的两个节点依次进行比较和调整，让键值（就是用它排
 序的字段，我们取学号num为键值）较大的节点往下沉，键值较小的往
 上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，
 就将它们互换。

单向链表的冒泡排序图示：
---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
head   1->next  3->next  2->next   n->next 

---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
head   1->next  2->next  3->next   n->next

图14：有N个节点的链表冒泡排序

任意两个相邻节点p、q位置互换图示:
假设p1->next指向p，那么显然p1->next->next就指向q,
p1->next->next->next就指向q的后继节点，我们用p2保存
p1->next->next指针。即：p2=p1->next->next，则有：
[  ]---->[p]---------->[q]---->[  ]（排序前）
  p1->next  p1->next->next  p2->next
图15

[  ]---->[q]---------->[p]---->[  ]（排序后）

图16

1、排序后q节点指向p节点，在调整指向之前，我们要保存原p的指向节点地址，即：p2=p1->next->next；
2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;
3、在图15中p2->next原是q发出来的指向，排序后图16中q的指向要变为指向p的，而原来p1->next是指向p的，所以p2->next=p1->next;
4、在图15中p1->next原是指向p的，排序后图16中p1->next要指向q,原来p1->next->next（即p2)是指向q的，所以p1->next=p2;
5、至此，我们完成了相邻两节点的顺序交换。
6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾的扫描，只需要扫描到记录点为止。
   因为后面的都已经是排好序的了。
*/
struct student *BubbleSort(struct student *head)
{
 struct student *endpt; /*控制循环比较*/
 struct student *p; /*临时指针变量*/
 struct student *p1;
 struct student *p2;

 p1 = (struct student *)malloc(LEN);
 p1->next = head; /*注意理解：我们增加一个节点，放在第一个节点的前面，主要是为了便于比较。因为第一个节点没有前驱，我们不能交换地址。*/
 head = p1; /*让head指向p1节点，排序完成后，我们再把p1节点释放掉*/

 for (endpt=NULL; endpt!=head; endpt=p) /*结合第6点理解*/
 {
  for (p=p1=head; p1->next->next!=endpt; p1=p1->next)
  {
   if (p1->next->num > p1->next->next->num) /*如果前面的节点键值比后面节点的键值大，则交换*/
   {
    p2 = p1->next->next; /*结合第1点理解*/
    p1->next->next = p2->next; /*结合第2点理解*/
    p2->next = p1->next; /*结合第3点理解*/
    p1->next = p2; /*结合第4点理解*/
    p = p1->next->next; /*结合第6点理解*/
   }
  }
 }

 p1 = head; /*把p1的信息去掉*/
 head = head->next; /*让head指向排序后的第一个节点*/
 free(p1); /*释放p1*/
 p1 = NULL; /*p1置为NULL，保证不产生“野指针”，即地址不确定的指针变量*/

 return head;
}

/*
==========================
 功能：插入有序链表的某个节点的后面(从小到大)
 返回：指向链表表头的指针
==========================
*/

/*
有序链表插入节点示意图：

---->[NULL]（空有序链表）
head

图18：空有序链表（空有序链表好解决，直接让head指向它就是了。）

以下讨论不为空的有序链表。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（有序链表）
head   1->next  2->next  3->next   n->next

图18：有N个节点的有序链表

插入node节点的位置有两种情况：一是第一个节点前，二是其它节点前或后。

---->[node]---->[1]---->[2]---->[3]...---->[n]---->[NULL]
head  node->next  1->next  2->next  3->next   n->next

图19：node节点插在第一个节点前

---->[1]---->[2]---->[3]...---->[node]...---->[n]---->[NULL]
head   1->next  2->next  3->next    node->next  n->next

图20：node节点插在其它节点后
*/
struct student *SortInsert(struct student *head, struct student *node)
{
 struct student *p; /*p保存当前需要检查的节点的地址*/
 struct student *t; /*临时指针变量*/

 if (head == NULL) /*处理空的有序链表*/
 {
  head = node;
  node->next = NULL;
  n += 1; /*插入完毕，节点总数加1*/
  return head;
 }

 p = head; /*有序链表不为空*/
 while (p->num < node->num && p != NULL) /*p指向的节点的学号比插入节点的学号小，并且它不等于NULL*/
 {
  t = p; /*保存当前节点的前驱，以便后面判断后处理*/
  p = p->next; /*后移一个节点*/
 }
 
 
 if (p == head)  /*刚好插入第一个节点之前*/
 {
  node->next = p;
  head = node;    
 }
 else /*插入其它节点之后*/
 { 
  t->next = node; /*把node节点加进去*/
  node->next = p; 
 }
 n += 1; /*插入完毕，节点总数加1*/
 
 return head;
}

/*

测试代码如下：

*/

/*测试SelectSort():请编译时去掉注释块*/

 /*
 head = SelectSort(head);
 Print(head);
 */
 
 /*测试InsertSort():请编译时去掉注释块*/

 /*
 head = InsertSort(head);
 Print(head);
 */

 /*测试BubbleSort():请编译时去掉注释块*/

 /*
 head = BubbleSort(head);
 Print(head);
 */

 /*测试SortInsert():上面创建链表，输入节点时请注意学号num从小到大的顺序。请编译时去掉注释块*/

 /*
 stu = (struct student *)malloc(LEN);
 printf(" Please input insert node -- num,score: ");
 scanf("%ld,%f",&stu->num,&stu->score);
 head = SortInsert(head,stu);
 free(stu);
 stu = NULL;
 Print(head);
 */

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/northplayboy/archive/2005/12/14/552388.aspx

在本题中，我想通过单独编写比较函数来完成升序和降序的比较，而

//不是给一个flag来给出升序和降序的选择。这种设计思想在标准C库函数早就在使用，因为

//你把比较的规则提炼出来，让调用者有了更多的处理空间，特别是当节点数据类型发生变

//时，人家能够编写这种比较函数实现对你的调用，代码的层次感和可复用思想就被体现出

//来了，当然有时是需要你来向考官阐述这种思想的，这种实现肯定能引起他的兴趣。希望

//下面的实现可以给大家一些启示，因为各人习惯不同，大家重在看其表达的思想，而不是

//代码本身。

// main.cpp : 定义控制台应用程序的入口点。

// 单链表（不含头节点）的排序

#include "stdafx.h"

#include <ctime>

#include <cassert>

typedef int DATATYPE;

//定义链表节点数据

typedef struct _NODETYPE

{

     DATATYPE data;

     struct _NODETYPE *next;

}NODETYPE, *PNODETYPE;

//定义链表节点大小比较函数

typedef bool (*COMPARE)(const PNODETYPE first, const PNODETYPE second);

/**

*@brief 简单异常处理函数    

*/

class CException

{

public:

     /**

    *@brief 默认构造函数

    *@param pMsg 异常描述字符串,前1024B有效

     */

     CException(const char *pMsg)

     {

         memset (m_msg, 0, 1024);

         //省略

         if(pMsg != NULL)

         {

             strncpy(m_msg, pMsg, 1024);

         }

     }

     /**

    *@brief 打印异常信息

     */

     void Print()

     {

         std::cout << m_msg << std::endl;

     }

     char m_msg[1024];

};//End of CException

#ifdef _DEBUG

/**

*@brief 利用堆栈特性实现调用跟踪

*/

class CInvokeDog

{

public:

     /**

    *@brief 在生成该类型变量时自动打印进入调用信息

    *@param pMsg 调用信息,前256B有效    

     */

     CInvokeDog(const char *pMsg)

     {

         memset (m_msg, 0, 256);

         if(pMsg != NULL)

         {

             strncpy(m_msg, pMsg, 256);

         }

         printf("Enter : %s ", m_msg);

     }

     /**

    *@brief 在析构该类型变量时自动打印退出调用信息

     */

     ~CInvokeDog()

     {

         printf("Leave : %s ", m_msg);

     }

private:

     char m_msg[256];

};// End of CInvokeDog

//调试信息输出

#define DEBUG_OUT(msg)

     printf("DEBUG:%s file[%s] line[%d] function[%s]",msg,   __FILE__, __LINE__, __FUNCTION__);

#define InvokeDog(msg) CInvokeDog _dog(msg);

#else

//调试信息输出

#define DEBUG_OUT(msg);

#define InvokeDog(msg)

#endif

/**

*@brief 升序比较两个链表节点值

*@param first 第一个链表节点

*@param second 第二个链表节点

*@return 如果first小于second 返回true,反之返回false

*@exception 当其中任意节点为NULL时抛出 “参数非法”CException 异常

*/

bool ASCEND(const PNODETYPE first, const PNODETYPE second)

{

     //参数有效性检查

     assert(first != NULL && second != NULL);

     if(first != NULL && second != NULL)

     {

         return (first->data < second->data);

     }

     DEBUG_OUT("参数非法");

     throw new CException("参数非法");

}//End of ASCEND()

/**

*@brief 降序比较两个链表节点值

*@param first 第一个链表节点

*@param second 第二个链表节点

*@return 如果first大于second 返回true,反之返回false

*@exception 当其中任意节点为NULL时抛出 “参数非法”CException 异常

*/

inline bool DESCEND(const PNODETYPE first, const PNODETYPE second)

{

     return !ASCEND(first, second);

}//End of DESCEND()

/**

*@brief 打印链表

*@param pLink 链表第一个节点

*@exception 当节点为NULL时抛出 “参数非法”CException 异常

*/

void PrintLink(PNODETYPE pLink)

{

     //参数有效性检查

     assert(pLink != NULL);

     if(pLink == NULL)

     {

         DEBUG_OUT("参数非法");

         throw new CException("参数非法");

     }

     PNODETYPE p = pLink;

     while(p != NULL)

     {

         std::cout << p->data << " ";

         p = p->next;

     }

}//End of PrintLink()

/**

*@brief 单链表排序

*@param pLink 单链表首节点

*@param compare 比较函数,默认为升序

*@return 排序后的链表首节点

*@exception 当首节点为NULL时抛出 “参数非法”CException 异常

*/

PNODETYPE SortLink( PNODETYPE pLink , COMPARE compare = ASCEND)

{

     InvokeDog(__FUNCTION__);

     //参数有效性检查

     assert(pLink != NULL && compare != NULL);

     if(pLink != NULL && compare != NULL)

     {

         PNODETYPE pSort = pLink; //排序后的链表头节点，假设第一个节点有序。

         PNODETYPE pLeft = pSort->next; //未排序的链表头节点。

         pSort->next = NULL;

         while(pLeft != NULL)

         {

             PNODETYPE pNext = pLeft->next;   //保存未排序的下一个节点

             //将当前节点在已排序的链表中定位

             PNODETYPE p = pSort;

             //需要更改头节点

             if(!compare(p, pLeft))

             {

                 pLeft->next = pSort;

                 pSort = pLeft;

             }

             else

             {

                 while(p->next != NULL && compare(p->next, pLeft))p = p->next;

                 pLeft->next = p->next;

                 p->next = pLeft;

             }

             pLeft = pNext;

         }

         return pSort;

     }

     DEBUG_OUT("参数非法");

     throw new CException("参数非法");

}// End of SortLink()

//main 主函数

int _tmain(int argc, _TCHAR* argv[])

{

     try

     {

         //初始化生成链表

         srand(time(NULL));

         PNODETYPE pLink = new NODETYPE;

         pLink->data = 100;

         pLink->next = NULL;

         for(int i   = 0; i < 10; i++)

         {

             PNODETYPE p = new NODETYPE;

             p->data = rand()%200;

             p->next = pLink->next;

             pLink->next = p;

         }

         //排序测试

         std::cout<< "初始串: " ;

         PrintLink(pLink);

         std::cout<< "升序后: " ;

         pLink = SortLink(pLink);

         PrintLink(pLink);

         std::cout<< "降序后: " ;

         pLink = SortLink(pLink, DESCEND);

         PrintLink(pLink);

         //释放链表

         while(pLink !=NULL)

         {

             PNODETYPE p = pLink;

             pLink = pLink->next;

             delete p;

             p = NULL;

         }

     }

     catch(CException *e)

     {

         e->Print();

         delete e;

     }

     return 0;

}

 

 异常情况下没释放链表内存 :把 PNODETYPE pLink = new NODETYPE; 放在try之上行并修改为 PNODETYPE pLink = NULL; 修改原处 PNODETYPE pLink = new NODETYPE;为 pLink = new NODETYPE; 在函数最后加上 if(NULL != pLink ) { delete pLink ; pLink = NULL; }