单链表操作

#ifndef LIST_H
#define LIST_H

typedef unsigned int Item;  
typedef unsigned char byte;  
struct node  
{  
  Item item;    // 卫星数据   
  struct node * next;  
};  
typedef struct node * List;           

void ListAddItem(List *plist, const Item item);
struct node * ListSearchItem(const List list, const Item item);
void ListDelItem(List *plist, const Item item);
void ListDel(List *plist);
void ListInvert(List *plist);
bool ListIsLoop(const List list);
struct node * ListConcatenate(List list1, List list2);
#endif

 

#include "stdafx.h"
#include "list.h"
#include <assert.h>
#include <malloc.h>

static inline void CopyItem(Item item, struct node* pnode)  
{  
    pnode->item = item;    
}  

static inline int ItemCmp(Item item1, Item item2)  
{  
    return item1 > item2 ? 1 : (item1 == item2 ? 0 : -1);
}  


/**********************************************
    向链表中插入节点
    当链表为空时,需要改变链表头所指向的内容,因此入参用链表头指针
**********************************************/
void ListAddItem(List *plist, const Item item)
{
    assert(NULL != plist);

    struct node *pnew;
    pnew = (struct node *)malloc(sizeof(struct node));  
    assert(NULL != pnew);
    
    CopyItem(item,pnew); 

    // 从小到大排列
    struct node *pscan = *plist;
    struct node *pinsert = NULL;
    while (NULL != pscan)
    {
        // 若是只需要插入到链表尾，可以去掉if-else条件，将循环体改为
        // pinsert = pscan; pscan = pscan->next;
        if (ItemCmp(pscan->item, item) < 0)
        {
            pinsert = pscan;
            pscan = pscan->next;
        }
        else
        {
            break;  
        }
    }
    
    // 无比item小的节点或是空链表,链表头插入
    if (NULL == pinsert)
    {
        pnew->next = pscan;
        *plist = pnew;
    }
    else    // 链表中间或者链表尾部
    {
        pnew->next = pscan;
        pinsert->next = pnew;
    }
}

/**********************************************   
 若相应的item存在，则返回第一个item的前驱(头节点的
 前驱为NULL)
 否则返回NULL
**********************************************/ 
struct node * ListSearchItem(const List list, const Item item)
{
    struct node * pscan = list;
    struct node * pprev = NULL;

    while (NULL != pscan)
    {
        if (ItemCmp(pscan->item, item) == 0)
        {
            return pprev;    
        }
        else
        {
            pprev = pscan;
            pscan = pscan->next;
        }
    }

    return NULL;
}


/**********************************************    
// 删除元素   
// 返回值:0,删除失败(不存在该item),1:删除成功   
**********************************************/ 
void ListDelItem(List *plist, const Item item)
{
    assert(NULL != plist);
    
    struct node *ptemp = *plist;
    if (NULL == ptemp)  // 空链表
        return;
    
    struct node *pdel = ListSearchItem(*plist, item); 
    if (NULL == pdel)
    {
        if (ItemCmp((*plist)->item, item) == 0)
        {
            pdel = *plist;
            *plist = pdel->next;
            free(pdel);
        }
    }
    else
    {
        ptemp = pdel->next;  // item所在节点   
        pdel->next = pdel->next->next;  
        free(ptemp);     
    }
}


/**********************************************   
// 删除链表   
**********************************************/ 
void ListDel(List *plist)
{
    assert(NULL != plist);

    struct node *pscan;
    struct node *pdel;

    pscan = *plist;

    while (NULL != pscan)
    {
        pdel = pscan;
        pscan = pscan->next;
        free(pdel);
    }
    
    *plist = NULL;
}

/**********************************************
    单链表翻转：采用3个指针就地翻转
**********************************************/
void ListInvert(List *plist)
{
    assert(NULL != plist);

    struct node *head, *tail, *pscan;

    head = NULL;
    pscan = *plist;

    while (pscan)
    {
        tail = head;
        head = pscan;
        pscan = pscan->next;
        head->next = tail;
    }

    *plist = head;
}

/**********************************************
 检查单链表是否有环:
    采用2个指针以不同的步长移动，若有环,则快的一定
 能追上慢的
**********************************************/
bool ListIsLoop(const List list)
{
    struct node *fast;   
    struct node *slow;

    if (NULL == list)
        return false;
    
    slow = list;
    fast = list->next;

    while (NULL != fast)
    {
        if (slow == fast)
            return true;

        slow = slow->next;
        
        fast = fast->next;
        if (NULL == fast)
            return false;
        fast = fast->next;
    }

    return false;
}

/**********************************************
串接2个单链表:
    将list2串接到list1之后,返回串接后的链表头
**********************************************/
struct node * ListConcatenate(List list1, List list2)
{
    struct node *ptemp;

    if (NULL == list1)
        return list2;
    
    ptemp = list1;
    while (NULL != ptemp->next)
        ptemp = ptemp->next;

    ptemp->next = list2;

    return list1;
}

/**********************************************
 判断两个链表是否相交:
    将两个链表串接起来，判断是否有环
**********************************************/