C语言有头结点链表的经典实现

        经常用到链表，但每次写都不那么顺利，终于有点时间整理一下，把感觉写的不错的代码拿出来分享，希望大家能指出问题，那我算没白写。 该链表以存放整型数据为例。

头文件：

 

#ifndef __LINK_H__
#define  __LINK_H__

#define  ERROR ( -1 )
#define  OK      ( 0  )

#define  TRUE  ( 1 == 1 )
#define  FALSE ( !TRUE  )


typedef  int  BOOL;
typedef  int  elem_t;             // 定义元素的数据类型 

typedef  struct  node
... {
    elem_t data;
    struct node * next;
} tagNode_t,tagList_t;


/**/ /* 把已经存在的头节点进行初始化为一个空链表 */
void  initList ( tagList_t  *  list );
/**/ /* 销毁链表 */
void  destroyList( tagList_t  *  list );

/**/ /* 将链表重置为空 */
void  clearList( tagList_t  *  list );

BOOL listEmpty( tagList_t  *  list );

int  listLength( tagList_t  *  list );

/**/ /* 得到指定位置 pos 的元素，如果顺利得到则返回TRUE，否则返回 FALSE*/
BOOL getElem( tagList_t  *  list,  int  iPos, elem_t  *  e);

/**/ /* 返回第一个满足 compare 关系的元素的位置，如果不存在则返回 -1 */
int  locateElem( tagList_t  *  list, elem_t e, 
    BOOL ( * compare)(elem_t e1,elem_t e2));

/**/ /* 将元素e插到链表的指定位置 ,若iPos > listLength() 则插到最后*/
BOOL listInsert( tagList_t  *  list,  int  iPos, elem_t e );

BOOL listInsertFront( tagList_t  *  list, elem_t e );

/**/ /* 按照费递减序插入元素 e */
BOOL listSortInsert( tagList_t  *  list, elem_t e );

BOOL listDeleteFront( tagList_t  *  list, elem_t  *  e );

/**/ /* 用visit 函数遍历链表 */
void  listTraverse( tagList_t  *  list,  void  ( * visit)(elem_t e));


#endif

 

源文件：

 

#include  < stdio.h >
#include  < stdlib.h >
#include  < assert.h >
#include  " link.h "


/**/ /* 把已经存在的头节点进行初始化为一个空链表 */
void  initList ( tagList_t  *  list )
... {
    list->next = NULL;
}
/**/ /* 销毁链表,没有释放头结点 */
void  destroyList( tagList_t  *  list )
... {
    tagNode_t * pn = NULL;
    assert( list != NULL );
    
    pn = list->next;
    while( pn != NULL)
    ...{
        list->next = pn->next;
        free( pn );
        pn = list->next;
    }
}

/**/ /* 将链表重置为空 */
void  clearList( tagList_t  *  list )
... {
    destroyList( list );  //同 销毁 
}

BOOL listEmpty( tagList_t  *  list )
... {
    return ( NULL == list->next );
}

int  listLength( tagList_t  *  list )
... {
    int iLen = 0;
    tagNode_t * ptn = NULL;
    assert( list != NULL );
    
    ptn = list->next;
    while( ptn != NULL )
    ...{
        iLen += 1;
        ptn = ptn->next;
    }
    return iLen;
}

/**/ /* 得到指定位置 pos 的元素，如果顺利得到则返回TRUE，否则返回 FALSE*/
BOOL getElem( tagList_t  *  list,  int  iPos, elem_t  *  e)
... {
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL;
    assert( list );        //list != NULL
    
    if( list || ( iPos >= 0 ) )
    ...{
        ptn = list->next;
        while( iPos-- && ptn )
        ...{
            ptn = ptn->next;
        }        
        if( ptn != NULL )
        ...{
            *e = ptn->data;
            bRet = TRUE;
        }        
    }
    return bRet;    
}

/**/ /* 返回第一个满足 compare 关系的元素的位置，如果不存在则返回 0 */
int  locateElem( tagList_t  *  list, elem_t e, 
    BOOL ( * compare)(elem_t e1,elem_t e2))
... {
    int iPos = 0;
    tagNode_t * ptn = NULL;
    assert( list );        //list != NULL
    
    ptn = list->next;
    while( ptn )
    ...{
        iPos += 1;
        if( compare( e, ptn->data ) )
        ...{
            break;
        }
        ptn = ptn->next;
    }
    if( NULL == ptn )
    ...{
        iPos = 0;
    }
    return iPos;
    
}

/**/ /* 将元素e插到链表的指定位置 ,若iPos > listLength() 则插到最后*/
BOOL listInsert( tagList_t  *  list,  int  iPos, elem_t e )
... {
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );        //list != NULL
    
    if( list || (iPos >= 0) )
    ...{
        ptn = list->next;
        while( iPos-- && ptn->next )
        ...{
            ptn = ptn->next;
        }        

        pstNew = ( tagNode_t * )malloc( sizeof( tagNode_t ) );
        if( pstNew != NULL )
        ...{
            pstNew->data = e;
            pstNew->next = ptn->next;
            ptn->next = pstNew;
            
            bRet = TRUE;
        }    
    }
    return bRet;
}

BOOL listInsertFront( tagList_t  *  list, elem_t e )
... {
    BOOL bRet = FALSE;
    tagNode_t * pstNew = 
        ( tagNode_t * )malloc( sizeof( tagNode_t ) );
    assert( list );
    
    if( pstNew != NULL )
    ...{
        pstNew->data = e;
        pstNew->next = list->next;
        list->next = pstNew;
        
        bRet = TRUE;
    }
    return bRet;
}

/**/ /* 按照非递减序插入元素 e */
BOOL listSortInsert( tagList_t  *  list, elem_t e )
... {
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );
    
    ptn = list;
    while( ptn->next )
    ...{
        if( ptn->next->data > e )
        ...{        
            bRet = TRUE;
            break;
        }
        ptn = ptn->next;
    }
    
    pstNew = ( tagNode_t * )malloc( sizeof( tagNode_t ) );
    if( pstNew != NULL)
    ...{
        pstNew->data = e;
        pstNew->next = ptn->next;
        ptn->next = pstNew;
        
        bRet = TRUE;
    }

    return bRet;
}

BOOL listDeleteFront( tagList_t  *  list, elem_t  *  e )
... {
    BOOL bRet = FALSE;
    tagNode_t * ptn = NULL;
    
    if( list != NULL )
    ...{
        ptn = list->next;
        *e = ptn->data;
        list->next = ptn->next;
        free( ptn );
        bRet = TRUE;
    }
    return bRet;
}

/**/ /* 用visit 函数遍历链表 */
void  listTraverse( tagList_t  *  list,  void  ( * visit)(elem_t e))
... {
    tagNode_t * ptn = NULL, * pstNew = NULL;
    assert( list );
    
    ptn = list->next;
    while( ptn )
    ...{
        visit( ptn->data );
        ptn = ptn->next;
    }
}

 

测试文件：

 

include  < stdio.h >
#include  " link.h "

void  tst_link()
... {
    elem_t e;
    tagList_t list;
    
    printf("********Test Stack******** ");
    
    initList( &list );
    
    printf("IsEmpty: %s ",(listEmpty( &list ) ? "true":"false"));
    
    listSortInsert( &list, 4 );
    listSortInsert( &list, 3 );
    
    printf("5 in pos: %d ",locateElem( &list,5,elemEqual ));
    
    listSortInsert( &list, 5 );
    
    printf("5 in pos: %d ",locateElem( &list,5,elemEqual ));
    
    listSortInsert( &list, 7 );
    listSortInsert( &list, 2 );
    
    printf("getElem (3) %s : %d ",(getElem( &list, 3, &e )?"right":"error"),e);
    printf("getElem (6) %s : %d ",(getElem( &list, 6, &e )?"right":"error"),e);
    
    listPrint( &list );
    printf(" ");
    
    printf("len: %d ",listLength( &list ));
    listDeleteFront( &list, &e );
    printf("After delete front len: %d ",listLength( &list ));
    printf("IsEmpty: %s ",(listEmpty( &list ) ? "true":"false"));
    printf("5 in pos: %d ",locateElem( &list,5,elemEqual ));
    
    destroyList( &list );
    
    printf("IsEmpty: %s ",(listEmpty( &list ) ? "true":"false"));
}