单链表的排序

问题： 将无序的单链表按从小到大排序

创新方法： 只对结点存放的值修改。  

思路：建立指针数组，映射到结点存放的值的地址， 然后间接访问这些结点的值，对它们排序。

代码：

预编译 

#include <stdlib.h>
#include <stdio.h>
#define status int
#define FALSE 0
#define TRUE 1

采用的链表结构

typedef struct NODE{
    struct NODE *next;    /* 指向下一个结点 */
    int value;            /* 存放结点值 */
} Node, *PNode, **List; 

typedef struct LINK{
    struct NODE *next;    /* 指向下一个结点 */
} Linker;

单链表排序

/*
功能描述:
    对单链表排序( 从大到小 )

参数：
    p_head -- 链表的头指针

返回值：
     如果排序成功，返回TRUE; 否则， 返回FALSE 
*/
status
SortTheChain( Linker *p_head )
{
        static int Count( Linker  *p_head );
        static status Map( Linker *p_head, int  ***p_index, int node_num );

    int node_num;        /* 存放链表中结点个数 */
    int **index = NULL; /* 存放映射 */
    int i, j;            /* 分别控制比较的趟数和次数 */
    int temp;            

    /* 计算结点个数 */
    node_num = Count( p_head );
    
    /* 映射结点的value字段 */
    if ( Map( p_head, &index, node_num ) == FALSE ){
        printf( "映射失败
" );
        return FALSE;
    }

    /* 排序 */
    for ( i = 1; i <= node_num - 1; i ++ ){
        for ( j = 0; j < node_num - i; j ++ ){
            if ( *index [j] < *index [j + 1] ){
                temp = *index [j];
                *index [j] = *index [j + 1];
                *index [j + 1] = temp;
            }
        }
    }
    
    /* 释放掉映射 */
    free( index );
    index = NULL;
    return TRUE;
} 


/*
功能描述:
    计算单链表的长度

参数:
    p_head -- 指向链表的头结点 

返回值:
    返回链表中结点个数 
*/
static int 
Count( Linker *p_head )
{
    PNode p = NULL;
    int num = 0;
    
    if ( p_head == NULL ){
        printf( "链表不存在
" );
        return num;
    }

    for ( p = p_head->next; 
            p != NULL;
            p = p->next ){
                num ++;
            }

    return num;    
}

/*
功能描述:
    映射整形指针到单链表value字段的地址 

参数:
    p_head -- 指向头结点  
    index -- 指向待映射的整形指针集
    node_num -- 链表的结点个数 
    
返回值:
    如果映射成功， 返回TRUE； 否则， 返回FALSE 
*/
static status 
Map( Linker *p_head, int ***p_index, int node_num )
{
    int i;
    PNode p = NULL;

    /* 申请内存 */
    *p_index = (int **) malloc ( node_num * sizeof(int *) );
    if ( *p_index == NULL ){
        printf( "内存不足
" );
        return FALSE;
    }
    
    /* 建立映射 */
    for ( i = 0, p = p_head->next; p != NULL; p = p->next ){
        (*p_index) [i ++] = &p->value;
    }
    return TRUE;
}