单向链表的简单使用

Posted oneway1990

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了单向链表的简单使用相关的知识，希望对你有一定的参考价值。

一、单向链表的概念

    单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，head指针指向第一个结点称为表头，而终止于最后一个指向nuLL的指针。

    结点的数据结构

 

[objc] view plain copy
 
 
print?
  1. typedef struct _LINK_NODE    
  2. {    
  3.     int data;    
  4.     struct _LINK_NODE* next;    
  5. }LINK_NODE;   
typedef struct _LINK_NODE  
{  
    int data;  
    struct _LINK_NODE* next;  
}LINK_NODE;


    各个结点连接在一起构成一个单向链表（示意图）

 

技术分享图片

 

二、单向链表的优缺点
    和普通的线性结构（如数组）相比，链表结构有以下特点：
    （1）单个结点创建非常灵活，普通的线性内存通常在创建的时候就需要设定数据的大小
    （2）结点的删除、插入非常方便，不需要像线性结构那样移动剩下的数据

    （3）结点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表

 

三、单向链表的基本操作

    1、建立一个新的链表

 

[objc] view plain copy
 
 
print?
  1. LINK_NODE* create_node(int value)    
  2. {    
  3.     LINK_NODE *pLinkNode = NULL;    
  4.       
  5.     pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));          
  6.     pLinkNode->data = value;    
  7.     pLinkNode->next = NULL;    
  8.       
  9.     return pLinkNode;    
  10. }    
LINK_NODE* create_node(int value)  
{  
    LINK_NODE *pLinkNode = NULL;  
    
    pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));        
    pLinkNode->data = value;  
    pLinkNode->next = NULL;  
    
    return pLinkNode;  
}

 

    2、增加一个结点（增加到末尾）

 

[objc] view plain copy
 
 
print?
  1. int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)    
  2. {    
  3.     if(NULL == *pNode) {    
  4.         *pNode = pDataNode;    
  5.         return TRUE;    
  6.     }    
  7.         
  8.     return _add_node(&(*pNode)->next, pDataNode);    
  9. }    
  10.     
  11. int add_node(const LINK_NODE** pNode, int value)    
  12. {    
  13.     LINK_NODE *pDataNode;    
  14.       
  15.     if(NULL == *pNode) {   
  16.         return FALSE;    
  17.     }  
  18.                 
  19.     pDataNode = create_node(value);    
  20.     if(pDataNode == NULL) {  
  21.         return FALSE;  
  22.     }    
  23.       
  24.     return _add_node((LINK_NODE**)pNode, pDataNode);    
  25. }    
int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)  
{  
    if(NULL == *pNode) {  
        *pNode = pDataNode;  
        return TRUE;  
    }  
      
    return _add_node(&(*pNode)->next, pDataNode);  
}  
  
int add_node(const LINK_NODE** pNode, int value)  
{  
    LINK_NODE *pDataNode;  
    
    if(NULL == *pNode) { 
        return FALSE;  
    }
              
    pDataNode = create_node(value);  
    if(pDataNode == NULL) {
        return FALSE;
    }  
    
    return _add_node((LINK_NODE**)pNode, pDataNode);  
}

 

    3、删除一个结点

 

[objc] view plain copy
 
 
print?
  1. int _delete_node(LINK_NODE** pNode, int value)    
  2. {    
  3.     LINK_NODE* pLinkNode;   
  4.        
  5.     if(NULL == (*pNode)->next) {  
  6.         return FALSE;    
  7.     }  
  8.     pLinkNode = (*pNode)->next;    
  9.     if(value == pLinkNode->data) {    
  10.         (*pNode)->next = pLinkNode->next;    
  11.         free(pLinkNode);    
  12.         return TRUE;    
  13.     } else {    
  14.         return _delete_node(&(*pNode)->next, value);    
  15.     }    
  16. }    
  17.     
  18. int delete_node(LINK_NODE** pNode, int value)    
  19. {    
  20.     LINK_NODE* pLinkNode;    
  21.       
  22.     if(NULL == pNode || NULL == *pNode) {   
  23.         return FALSE;    
  24.     }  
  25.       
  26.     if(value == (*pNode)->data) {    
  27.         pLinkNode = *pNode;    
  28.         *pNode = pLinkNode->next;    
  29.         free(pLinkNode);    
  30.         return TRUE;    
  31.     }           
  32.         
  33.     return _delete_node(pNode, value);    
  34. }    
int _delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode; 
     
    if(NULL == (*pNode)->next) {
        return FALSE;  
    }
    pLinkNode = (*pNode)->next;  
    if(value == pLinkNode->data) {  
        (*pNode)->next = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    } else {  
        return _delete_node(&(*pNode)->next, value);  
    }  
}  
  
int delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode;  
    
    if(NULL == pNode || NULL == *pNode) { 
        return FALSE;  
    }
    
    if(value == (*pNode)->data) {  
        pLinkNode = *pNode;  
        *pNode = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    }         
      
    return _delete_node(pNode, value);  
}

 

    4、查找结点

 

[objc] view plain copy
 
 
print?
  1. //查找结点，返回数据内容为value的结点地址，没有找到返回NULL  
  2. LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)    
  3. {    
  4.     if(NULL == pLinkNode)    
  5.         return NULL;    
  6.         
  7.     if(value == pLinkNode->data)    
  8.         return (LINK_NODE*)pLinkNode;    
  9.         
  10.     return find_node(pLinkNode->next, value);    
  11. }    
//查找结点，返回数据内容为value的结点地址，没有找到返回NULL
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)  
{  
    if(NULL == pLinkNode)  
        return NULL;  
      
    if(value == pLinkNode->data)  
        return (LINK_NODE*)pLinkNode;  
      
    return find_node(pLinkNode->next, value);  
}

 

    5、统计结点个数

 

[objc] view plain copy
 
 
print?
  1. int count_list(const LINK_NODE *pLinkNode)    
  2. {    
  3.     if(NULL == pLinkNode) {    
  4.         return 0;    
  5.     }  
  6.            
  7.     return 1 + count_list(pLinkNode->next);    
  8. }    
int count_list(const LINK_NODE *pLinkNode)  
{  
    if(NULL == pLinkNode) {  
        return 0;  
    }
         
    return 1 + count_list(pLinkNode->next);  
}

 

    6、打印整个链表

 

[objc] view plain copy
 
 
print?
  1. void print_list(const LINK_NODE *pLinkNode)    
  2. {    
  3.     if(pLinkNode) {    
  4.         printf("%d ", pLinkNode->data);    
  5.         print_list(pLinkNode->next);    
  6.     }    
  7. }    
void print_list(const LINK_NODE *pLinkNode)  
{  
    if(pLinkNode) {  
        printf("%d
", pLinkNode->data);  
        print_list(pLinkNode->next);  
    }  
}

 

    7、删除整个链表

 

[objc] view plain copy
 
 
print?
  1. void delete_list(LINK_NODE** pNode)    
  2. {    
  3.     LINK_NODE** pNext;    
  4.       
  5.     if(NULL == pNode || NULL == *pNode) {    
  6.         return ;    
  7.     }      
  8.     pNext = &(*pNode)->next;    
  9.     free(*pNode);    
  10.     delete_list(pNext);     
  11. }    
void delete_list(LINK_NODE** pNode)  
{  
    LINK_NODE** pNext;  
    
    if(NULL == pNode || NULL == *pNode) {  
        return ;  
    }    
    pNext = &(*pNode)->next;  
    free(*pNode);  
    delete_list(pNext);   
}

 

    8、链表逆转

        链表逆转就是把链表的方向反过来，头指针变成尾指针，尾指针变成头指针，实现草图如下

技术分享图片

        a、逆转并生成新的链表（非递归方式）

 

[objc] view plain copy
 
 
print?
  1. //新建一条链表，新的链表是原来链表的逆转，使用while循环实现。  
  2. LINK_NODE *reverse_new_loop(LINK_NODE *head)  
  3. {  
  4.     LINK_NODE *p1 = NULL, *p2;  
  5.       
  6.     while(head != NULL)  
  7.     {  
  8.         p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));  
  9.         if(p1 == NULL) {  
  10.             p2->next = NULL;   
  11.         } else {  
  12.             p2->next = p1;  
  13.         }  
  14.         p1 = p2;  
  15.         p2->data = head->data;  
  16.         head = head->next;  
  17.     }  
  18.       
  19.     return p1;  
  20. }  
//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head)
{
    LINK_NODE *p1 = NULL, *p2;
    
    while(head != NULL)
    {
        p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
        if(p1 == NULL) {
            p2->next = NULL; 
        } else {
            p2->next = p1;
        }
        p1 = p2;
        p2->data = head->data;
        head = head->next;
    }
    
    return p1;
}

 

        b、逆转并生成新的链表（递归方式）

 

[objc] view plain copy
 
 
print?
  1. //新建一条链表，新的链表是原来链表的逆转，使用递归实现。  
  2. LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)  
  3. {  
  4.     LINK_NODE *p = head->next;  
  5.     LINK_NODE *new;  
  6.       
  7.     new = (LINK_NODE *) malloc(sizeof(LINK_NODE));  
  8.     new->next = pre;  
  9.     new->data = head->data;  
  10.       
  11.     if(p) {  
  12.         return reverse_new_recursive(p, new);  
  13.     } else {  
  14.         return new;  
  15.     }  
  16. }  
//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)
{
    LINK_NODE *p = head->next;
    LINK_NODE *new;
    
    new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
    new->next = pre;
    new->data = head->data;
    
    if(p) {
        return reverse_new_recursive(p, new);
    } else {
        return new;
    }
}

 

        c、原地逆转，不生成新链表（非递归方式）

 

[objc] view plain copy
 
 
print?
  1. //原地逆转，使用while循环实现。  
  2. LINK_NODE *reverse_local_loop(LINK_NODE *head)   
  3. {  
  4.     LINK_NODE *p;  
  5.     LINK_NODE *tmp;  
  6.       
  7.     if(NULL == head) {  
  8.         return head;  
  9.     }  
  10.       
  11.     p = head->next;  
  12.     head->next = NULL;  
  13.   
  14.     while(NULL != p) {  
  15.         tmp = p->next;  
  16.         p->next = head;  
  17.         head = p;  
  18.         p = tmp;  
  19.     }  
  20.   
  21.     return head;  
  22. }  
//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head) 
{
    LINK_NODE *p;
    LINK_NODE *tmp;
    
    if(NULL == head) {
        return head;
    }
    
    p = head->next;
    head->next = NULL;

    while(NULL != p) {
        tmp = p->next;
        p->next = head;
        head = p;
        p = tmp;
    }

    return head;
}

 

        d、原地逆转，不生成新链表（递归方式）

 

[objc] view plain copy
 
 
print?
  1. //原地逆转，使用递归实现。  
  2. LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre)   
  3. {  
  4.     LINK_NODE *p = head->next;  
  5.   
  6.     head->next = pre;  
  7.     if(p) {  
  8.         return reverse_local_recursive(p, head);  
  9.     } else {  
  10.         return head;  
  11.     }  
  12. }  
//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre) 
{
    LINK_NODE *p = head->next;

    head->next = pre;
    if(p) {
        return reverse_local_recursive(p, head);
    } else {
        return head;
    }
}

 

    9、链表排序
        a、选择排序
            选择排序的基本思想就是反复从还未排好序的那些节点中，选出键值最小的节点， 依次重新组合成一个链表。可以通过以下三个步骤实现
            （1）先在原链表中找最小的，找到一个后就把它放到另一个空的链表中
            （2）空链表中存放第一个进来的节点，并且让它在原链表中分离出来

            （3）继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针

 

[objc] view plain copy
 
 
print?
  1. //选择排序，从小到大。  
  2. LINK_NODE *SelectSort(LINK_NODE *head)  
  3. {  
  4.     LINK_NODE *first;     /*排列后有序链的表头指针*/  
  5.     LINK_NODE *tail;      /*排列后有序链的表尾指针*/  
  6.     LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/  
  7.     LINK_NODE *min;       /*存储最小节点*/  
  8.     LINK_NODE *p;         /*当前比较的节点*/  
  9.   
  10.     first = NULL;  
  11.     while (head != NULL)   
  12.     {  
  13.           
  14.         //在剩余的原链表中找出最小值  
  15.         for (p = head, min = head; p->next != NULL; p = p->next) {    
  16.             if (p->next->data < min->data) {  
  17.                 premin = p;   
  18.                 min = p->next;   
  19.             }  
  20.         }  
  21.   
  22.         //将找出来最小值放到新的链表  
  23.         if (first == NULL) {  
  24.             first = min;   
  25.             tail = min;  
  26.         } else {  
  27.             tail->next = min;   
  28.             tail = min;  
  29.         }   
  30.   
  31.         //将找出来的最小值从原来的链表中脱离  
  32.         if (min == head) {  
  33.             head = head->next;  
  34.         } else {  
  35.             premin->next = min->next;  
  36.         }   
  37.     }  
  38.   
  39.     if (first != NULL) {  
  40.         tail->next = NULL;  
  41.     }  
  42.       
  43.     head = first;  
  44.     return head;  
  45. }  
//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head)
{
    LINK_NODE *first;     /*排列后有序链的表头指针*/
    LINK_NODE *tail;      /*排列后有序链的表尾指针*/
    LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/
    LINK_NODE *min;       /*存储最小节点*/
    LINK_NODE *p;         /*当前比较的节点*/

    first = NULL;
    while (head != NULL) 
    {
        
        //在剩余的原链表中找出最小值
        for (p = head, min = head; p->next != NULL; p = p->next) {  
            if (p->next->data < min->data) {
                premin = p; 
                min = p->next; 
            }
        }

        //将找出来最小值放到新的链表
        if (first == NULL) {
            first = min; 
            tail = min;
        } else {
            tail->next = min; 
            tail = min;
        } 

        //将找出来的最小值从原来的链表中脱离
        if (min == head) {
            head = head->next;
        } else {
            premin->next = min->next;
        } 
    }

    if (first != NULL) {
        tail->next = NULL;
    }
    
    head = first;
    return head;
}

 

        b、插入排序
            直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值排好序的，对于节点n在这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次对链表从头到尾执行一遍，就可以使无序链表变为有序链表。可以通过以下两个步骤实现
            （1）先在原链表中以第一个节点为一个有序链表，其余节点为待定节点

            （2）从原链表中依次取结点，插入到有序链表的相应位置，使得有序链表仍然有序，直至原链表的结点全部取完，排序结束。

 

[objc] view plain copy
 
 
print?
  1. //插入排序，从小到大。         
  2. LINK_NODE *InsertSort(LINK_NODE *head)  
  3. {  
  4.     LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/  
  5.     LINK_NODE *t;     /*临时指针变量：插入节点*/  
  6.     LINK_NODE *p;     /*临时指针变量*/  
  7.     LINK_NODE *q;     /*临时指针变量*/  
  8.   
  9.     first = head->next;   
  10.     head->next = NULL;   
  11.   
  12.     while (first != NULL)  
  13.     {  
  14.         //找到要插入的位置，p是q的前驱。  
  15.         for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);  
  16.   
  17.         //无序链表中的节点离开，以便它插入到有序链表中。  
  18.         first = first->next;  
  19.           
  20.         if (q == head) {  
  21.             head = t;  //插在第一个节点之前  
  22.         } else {  
  23.             p->next = t;    
  24.         }  
  25.         t->next = q;  
  26.     }  
  27.       
  28.     return head;  
  29. }        
//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head)
{
    LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/
    LINK_NODE *t;     /*临时指针变量：插入节点*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *q;     /*临时指针变量*/

    first = head->next; 
    head->next = NULL; 

    while (first != NULL)
    {
        //找到要插入的位置，p是q的前驱。
        for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

        //无序链表中的节点离开，以便它插入到有序链表中。
        first = first->next;
        
        if (q == head) {
            head = t;  //插在第一个节点之前
        } else {
            p->next = t;  
        }
        t->next = q;
    }
    
    return head;
}

 

        c、冒泡排序

            冒泡排序的基本思想就是对当前还未排好序的范围内的全部节点，自上而下对相邻的两个节点依次进行比较和调整，让键值较大的节点往下沉，键值较小的往上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，就将它们互换。

 

[objc] view plain copy
 
 
print?
  1. //冒泡排序，从小到大。  
  2. LINK_NODE *BubbleSort(LINK_NODE *head)  
  3. {  
  4.     LINK_NODE *endpt; /*控制循环比较*/  
  5.     LINK_NODE *p;     /*临时指针变量*/  
  6.     LINK_NODE *p1;  
  7.     LINK_NODE *p2;  
  8.   
  9.     p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));  
  10.     p1->next = head;  
  11.     head = p1;  
  12.   
  13.     for (endpt = NULL; endpt != head; endpt = p) {  
  14.         for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {  
  15.             if (p1->next->data > p1->next->next->data) {  
  16.                 p2 = p1->next->next;   
  17.                 p1->next->next = p2->next;   
  18.                 p2->next = p1->next;   
  19.                 p1->next = p2;   
  20.                 p = p1->next->next;   
  21.             }  
  22.         }  
  23.     }  
  24.   
  25.     p1 = head;   
  26.     head = head->next;  
  27.     free(p1);   
  28.     p1 = NULL;   
  29.   
  30.     return head;  
  31. }  
//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head)
{
    LINK_NODE *endpt; /*控制循环比较*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *p1;
    LINK_NODE *p2;

    p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
    p1->next = head;
    head = p1;

    for (endpt = NULL; endpt != head; endpt = p) {
        for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
            if (p1->next->data > p1->next->next->data) {
                p2 = p1->next->next; 
                p1->next->next = p2->next; 
                p2->next = p1->next; 
                p1->next = p2; 
                p = p1->next->next; 
            }
        }
    }

    p1 = head; 
    head = head->next;
    free(p1); 
    p1 = NULL; 

    return head;
}

 

四、单向链表运用示例

    将链表的基本操作统一放在一个文件single_linkedlist.c里面，然后在single_linkedlist.h文件里面声明，这样调用起来比较方便。下面贴出各个文件的代码，方面下次快速使用。

    single_linkedlist.c文件代码

 

[objc] view plain copy
 
 
print?
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.   
  4. #include "single_linkedlist.h"  
  5.   
  6. //创建一个结点  
  7. LINK_NODE* create_node(int value)    
  8. {    
  9.     LINK_NODE *pLinkNode = NULL;    
  10.       
  11.     pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));          
  12.     pLinkNode->data = value;    
  13.     pLinkNode->next = NULL;    
  14.       
  15.     return pLinkNode;    
  16. }    
  17.   
  18. //使用递归的方法，在链表的末尾加上一个新的结点  
  19. int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)    
  20. {    
  21.     if(NULL == *pNode) {    
  22.         *pNode = pDataNode;    
  23.         return TRUE;    
  24.     }    
  25.         
  26.     return _add_node(&(*pNode)->next, pDataNode);    
  27. }    
  28.     
  29. int add_node(const LINK_NODE** pNode, int value)    
  30. {    
  31.     LINK_NODE *pDataNode;    
  32.       
  33.     if(NULL == *pNode) {   
  34.         return FALSE;    
  35.     }  
  36.                 
  37.     pDataNode = create_node(value);    
  38.     if(pDataNode == NULL) {  
  39.         return FALSE;  
  40.     }    
  41.       
  42.     return _add_node((LINK_NODE**)pNode, pDataNode);    
  43. }    
  44.   
  45. //使用递归的方法，删除数据内容为value的结点  
  46. int _delete_node(LINK_NODE** pNode, int value)    
  47. {    
  48.     LINK_NODE* pLinkNode;   
  49.        
  50.     if(NULL == (*pNode)->next) {  
  51.         return FALSE;    
  52.     }  
  53.     pLinkNode = (*pNode)->next;    
  54.     if(value == pLinkNode->data) {    
  55.         (*pNode)->next = pLinkNode->next;    
  56.         free(pLinkNode);    
  57.         return TRUE;    
  58.     } else {    
  59.         return _delete_node(&(*pNode)->next, value);    
  60.     }    
  61. }    
  62.     
  63. int delete_node(LINK_NODE** pNode, int value)    
  64. {    
  65.     LINK_NODE* pLinkNode;    
  66.       
  67.     if(NULL == pNode || NULL == *pNode) {   
  68.         return FALSE;    
  69.     }  
  70.       
  71.     if(value == (*pNode)->data) {    
  72.         pLinkNode = *pNode;    
  73.         *pNode = pLinkNode->next;    
  74.         free(pLinkNode);    
  75.         return TRUE;    
  76.     }           
  77.         
  78.     return _delete_node(pNode, value);    
  79. }    
  80.   
  81. //查找结点，返回数据内容为value的结点地址，没有找到返回NULL.  
  82. LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)    
  83. {    
  84.     if(NULL == pLinkNode)    
  85.         return NULL;    
  86.         
  87.     if(value == pLinkNode->data)    
  88.         return (LINK_NODE*)pLinkNode;    
  89.         
  90.     return find_node(pLinkNode->next, value);    
  91. }    
  92.   
  93. //把从pLinkNode结点开始到链表结束的结点个数统计出来  
  94. //一般pLinkNode链表头  
  95. int count_list(const LINK_NODE *pLinkNode)    
  96. {    
  97.     if(NULL == pLinkNode) {    
  98.         return 0;    
  99.     }  
  100.            
  101.     return 1 + count_list(pLinkNode->next);    
  102. }    
  103.       
  104. //把从pLinkNode结点开始到链表结束的数据全部打印出来  
  105. //一般pLinkNode为链表头  
  106. void print_list(const LINK_NODE *pLinkNode)    
  107. {    
  108.     if(pLinkNode) {    
  109.         printf("%d ", pLinkNode->data);    
  110.         print_list(pLinkNode->next);    
  111.     }    
  112. }    
  113.   
  114. //删除整个链表，pNode为链表头。  
  115. void delete_list(LINK_NODE** pNode)    
  116. {    
  117.     LINK_NODE** pNext;    
  118.       
  119.     if(NULL == pNode || NULL == *pNode) {    
  120.         return ;    
  121.     }      
  122.     pNext = &(*pNode)->next;    
  123.     free(*pNode);    
  124.     delete_list(pNext);     
  125. }    
  126.   
  127. //新建一条链表，新的链表是原来链表的逆转，使用while循环实现。  
  128. LINK_NODE *reverse_new_loop(LINK_NODE *head)  
  129. {  
  130.     LINK_NODE *p1 = NULL, *p2;  
  131.       
  132.     while(head != NULL)  
  133.     {  
  134.         p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));  
  135.         if(p1 == NULL) {  
  136.             p2->next = NULL;   
  137.         } else {  
  138.             p2->next = p1;  
  139.         }  
  140.         p1 = p2;  
  141.         p2->data = head->data;  
  142.         head = head->next;  
  143.     }  
  144.       
  145.     return p1;  
  146. }  
  147.   
  148. //新建一条链表，新的链表是原来链表的逆转，使用递归实现。  
  149. LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)  
  150. {  
  151.     LINK_NODE *p = head->next;  
  152.     LINK_NODE *new;  
  153.       
  154.     new = (LINK_NODE *) malloc(sizeof(LINK_NODE));  
  155.     new->next = pre;  
  156.     new->data = head->data;  
  157.       
  158.     if(p) {  
  159.         return reverse_new_recursive(p, new);  
  160.     } else {  
  161.         return new;  
  162.     }  
  163. }  
  164.   
  165. //原地逆转，使用while循环实现。  
  166. LINK_NODE *reverse_local_loop(LINK_NODE *head)   
  167. {  
  168.     LINK_NODE *p;  
  169.     LINK_NODE *tmp;  
  170.       
  171.     if(NULL == head) {  
  172.         return head;  
  173.     }  
  174.       
  175.     p = head->next;  
  176.     head->next = NULL;  
  177.   
  178.     while(NULL != p) {  
  179.         tmp = p->next;  
  180.         p->next = head;  
  181.         head = p;  
  182.         p = tmp;  
  183.     }  
  184.   
  185.     return head;  
  186. }  
  187.   
  188. //原地逆转，使用递归实现。  
  189. LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre)   
  190. {  
  191.     LINK_NODE *p = head->next;  
  192.   
  193.     head->next = pre;  
  194.     if(p) {  
  195.         return reverse_local_recursive(p, head);  
  196.     } else {  
  197.         return head;  
  198.     }  
  199. }  
  200.   
  201. //选择排序，从小到大。  
  202. LINK_NODE *SelectSort(LINK_NODE *head)  
  203. {  
  204.     LINK_NODE *first;     /*排列后有序链的表头指针*/  
  205.     LINK_NODE *tail;      /*排列后有序链的表尾指针*/  
  206.     LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/  
  207.     LINK_NODE *min;       /*存储最小节点*/  
  208.     LINK_NODE *p;         /*当前比较的节点*/  
  209.   
  210.     first = NULL;  
  211.     while (head != NULL)   
  212.     {  
  213.           
  214.         //在剩余的原链表中找出最小值  
  215.         for (p = head, min = head; p->next != NULL; p = p->next) {    
  216.             if (p->next->data < min->data) {  
  217.                 premin = p;   
  218.                 min = p->next;   
  219.             }  
  220.         }  
  221.   
  222.         //将找出来最小值放到新的链表  
  223.         if (first == NULL) {  
  224.             first = min;   
  225.             tail = min;  
  226.         } else {  
  227.             tail->next = min;   
  228.             tail = min;  
  229.         }   
  230.   
  231.         //将找出来的最小值从原来的链表中脱离  
  232.         if (min == head) {  
  233.             head = head->next;  
  234.         } else {  
  235.             premin->next = min->next;  
  236.         }   
  237.     }  
  238.   
  239.     if (first != NULL) {  
  240.         tail->next = NULL;  
  241.     }  
  242.       
  243.     head = first;  
  244.     return head;  
  245. }  
  246.   
  247. //插入排序，从小到大。         
  248. LINK_NODE *InsertSort(LINK_NODE *head)  
  249. {  
  250.     LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/  
  251.     LINK_NODE *t;     /*临时指针变量：插入节点*/  
  252.     LINK_NODE *p;     /*临时指针变量*/  
  253.     LINK_NODE *q;     /*临时指针变量*/  
  254.   
  255.     first = head->next;   
  256.     head->next = NULL;   
  257.   
  258.     while (first != NULL)  
  259.     {  
  260.         //找到要插入的位置，p是q的前驱。  
  261.         for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);  
  262.   
  263.         //无序链表中的节点离开，以便它插入到有序链表中。  
  264.         first = first->next;  
  265.           
  266.         if (q == head) {  
  267.             head = t;  //插在第一个节点之前  
  268.         } else {  
  269.             p->next = t;    
  270.         }  
  271.         t->next = q;  
  272.     }  
  273.       
  274.     return head;  
  275. }        
  276.   
  277. //冒泡排序，从小到大。  
  278. LINK_NODE *BubbleSort(LINK_NODE *head)  
  279. {  
  280.     LINK_NODE *endpt; /*控制循环比较*/  
  281.     LINK_NODE *p;     /*临时指针变量*/  
  282.     LINK_NODE *p1;  
  283.     LINK_NODE *p2;  
  284.   
  285.     p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));  
  286.     p1->next = head;  
  287.     head = p1;  
  288.   
  289.     for (endpt = NULL; endpt != head; endpt = p) {  
  290.         for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {  
  291.             if (p1->next->data > p1->next->next->data) {  
  292.                 p2 = p1->next->next;   
  293.                 p1->next->next = p2->next;   
  294.                 p2->next = p1->next;   
  295.                 p1->next = p2;   
  296.                 p = p1->next->next;   
  297.             }  
  298.         }  
  299.     }  
  300.   
  301.     p1 = head;   
  302.     head = head->next;  
  303.     free(p1);   
  304.     p1 = NULL;   
  305.   
  306.     return head;  
  307. }  
#include <stdio.h>
#include <stdlib.h>

#include "single_linkedlist.h"

//创建一个结点
LINK_NODE* create_node(int value)  
{  
    LINK_NODE *pLinkNode = NULL;  
    
    pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));        
    pLinkNode->data = value;  
    pLinkNode->next = NULL;  
    
    return pLinkNode;  
}  

//使用递归的方法，在链表的末尾加上一个新的结点
int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)  
{  
    if(NULL == *pNode) {  
        *pNode = pDataNode;  
        return TRUE;  
    }  
      
    return _add_node(&(*pNode)->next, pDataNode);  
}  
  
int add_node(const LINK_NODE** pNode, int value)  
{  
    LINK_NODE *pDataNode;  
    
    if(NULL == *pNode) { 
        return FALSE;  
    }
              
    pDataNode = create_node(value);  
    if(pDataNode == NULL) {
        return FALSE;
    }  
    
    return _add_node((LINK_NODE**)pNode, pDataNode);  
}  

//使用递归的方法，删除数据内容为value的结点
int _delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode; 
     
    if(NULL == (*pNode)->next) {
        return FALSE;  
    }
    pLinkNode = (*pNode)->next;  
    if(value == pLinkNode->data) {  
        (*pNode)->next = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    } else {  
        return _delete_node(&(*pNode)->next, value);  
    }  
}  
  
int delete_node(LINK_NODE** pNode, int value)  
{  
    LINK_NODE* pLinkNode;  
    
    if(NULL == pNode || NULL == *pNode) { 
        return FALSE;  
    }
    
    if(value == (*pNode)->data) {  
        pLinkNode = *pNode;  
        *pNode = pLinkNode->next;  
        free(pLinkNode);  
        return TRUE;  
    }         
      
    return _delete_node(pNode, value);  
}  

//查找结点，返回数据内容为value的结点地址，没有找到返回NULL.
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)  
{  
    if(NULL == pLinkNode)  
        return NULL;  
      
    if(value == pLinkNode->data)  
        return (LINK_NODE*)pLinkNode;  
      
    return find_node(pLinkNode->next, value);  
}  

//把从pLinkNode结点开始到链表结束的结点个数统计出来
//一般pLinkNode链表头
int count_list(const LINK_NODE *pLinkNode)  
{  
    if(NULL == pLinkNode) {  
        return 0;  
    }
         
    return 1 + count_list(pLinkNode->next);  
}  
    
//把从pLinkNode结点开始到链表结束的数据全部打印出来
//一般pLinkNode为链表头
void print_list(const LINK_NODE *pLinkNode)  
{  
    if(pLinkNode) {  
        printf("%d
", pLinkNode->data);  
        print_list(pLinkNode->next);  
    }  
}  

//删除整个链表，pNode为链表头。
void delete_list(LINK_NODE** pNode)  
{  
    LINK_NODE** pNext;  
    
    if(NULL == pNode || NULL == *pNode) {  
        return ;  
    }    
    pNext = &(*pNode)->next;  
    free(*pNode);  
    delete_list(pNext);   
}  

//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head)
{
    LINK_NODE *p1 = NULL, *p2;
    
    while(head != NULL)
    {
        p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
        if(p1 == NULL) {
            p2->next = NULL; 
        } else {
            p2->next = p1;
        }
        p1 = p2;
        p2->data = head->data;
        head = head->next;
    }
    
    return p1;
}

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)
{
    LINK_NODE *p = head->next;
    LINK_NODE *new;
    
    new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
    new->next = pre;
    new->data = head->data;
    
    if(p) {
        return reverse_new_recursive(p, new);
    } else {
        return new;
    }
}

//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head) 
{
    LINK_NODE *p;
    LINK_NODE *tmp;
    
    if(NULL == head) {
        return head;
    }
    
    p = head->next;
    head->next = NULL;

    while(NULL != p) {
        tmp = p->next;
        p->next = head;
        head = p;
        p = tmp;
    }

    return head;
}

//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre) 
{
    LINK_NODE *p = head->next;

    head->next = pre;
    if(p) {
        return reverse_local_recursive(p, head);
    } else {
        return head;
    }
}

//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head)
{
    LINK_NODE *first;     /*排列后有序链的表头指针*/
    LINK_NODE *tail;      /*排列后有序链的表尾指针*/
    LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/
    LINK_NODE *min;       /*存储最小节点*/
    LINK_NODE *p;         /*当前比较的节点*/

    first = NULL;
    while (head != NULL) 
    {
        
        //在剩余的原链表中找出最小值
        for (p = head, min = head; p->next != NULL; p = p->next) {  
            if (p->next->data < min->data) {
                premin = p; 
                min = p->next; 
            }
        }

        //将找出来最小值放到新的链表
        if (first == NULL) {
            first = min; 
            tail = min;
        } else {
            tail->next = min; 
            tail = min;
        } 

        //将找出来的最小值从原来的链表中脱离
        if (min == head) {
            head = head->next;
        } else {
            premin->next = min->next;
        } 
    }

    if (first != NULL) {
        tail->next = NULL;
    }
    
    head = first;
    return head;
}

//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head)
{
    LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/
    LINK_NODE *t;     /*临时指针变量：插入节点*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *q;     /*临时指针变量*/

    first = head->next; 
    head->next = NULL; 

    while (first != NULL)
    {
        //找到要插入的位置，p是q的前驱。
        for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

        //无序链表中的节点离开，以便它插入到有序链表中。
        first = first->next;
        
        if (q == head) {
            head = t;  //插在第一个节点之前
        } else {
            p->next = t;  
        }
        t->next = q;
    }
    
    return head;
}      

//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head)
{
    LINK_NODE *endpt; /*控制循环比较*/
    LINK_NODE *p;     /*临时指针变量*/
    LINK_NODE *p1;
    LINK_NODE *p2;

    p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
    p1->next = head;
    head = p1;

    for (endpt = NULL; endpt != head; endpt = p) {
        for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
            if (p1->next->data > p1->next->next->data) {
                p2 = p1->next->next; 
                p1->next->next = p2->next; 
                p2->next = p1->next; 
                p1->next = p2; 
                p = p1->next->next; 
            }
        }
    }

    p1 = head; 
    head = head->next;
    free(p1); 
    p1 = NULL; 

    return head;
}


    single_linkedlist.h文件代码

 

 

[objc] view plain copy
 
 
print?
  1. #ifndef _SINGLE_LINKEDLIST_H_  
  2. #define _SINGLE_LINKEDLIST_H_  
  3.   
  4. #define TRUE       1  
  5. #define FALSE      0  
  6.   
  7. //定义结点数据结构  
  8. typedef struct _LINK_NODE    
  9. {    
  10.     int data;    
  11.     struct _LINK_NODE* next;    
  12. }LINK_NODE;   
  13.   
  14.   
  15. //创建一个结点  
  16. LINK_NODE* create_node(int value);  
  17.   
  18. //删除整个链表，pNode为链表头。  
  19. void delete_list(LINK_NODE** pNode);   
  20.   
  21. //使用递归的方法，在链表的末尾加上一个新的结点  
  22. int add_node(const LINK_NODE** pNode, int value);  
  23.   
  24. //使用递归的方法，删除数据内容为value的结点  
  25. int delete_node(LINK_NODE** pNode, int value);  
  26.   
  27. //查找结点，返回数据内容为value的结点地址，没有找到返回NULL  
  28. LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value);  
  29.   
  30. //把从pLinkNode结点开始到链表结束的结点个数统计出来  
  31. //一般pLinkNode链表头  
  32. int count_list(const LINK_NODE *pLinkNode);  
  33.   
  34. //把从pLinkNode结点开始到链表结束的数据全部打印出来  
  35. //一般pLinkNode为链表头  
  36. void print_list(const LINK_NODE *pLinkNode);   
  37.   
  38. //新建一条链表，新的链表是原来链表的逆转，使用while循环实现。  
  39. LINK_NODE *reverse_new_loop(LINK_NODE *head);  
  40.   
  41. //新建一条链表，新的链表是原来链表的逆转，使用递归实现。  
  42. LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre);  
  43.   
  44. //原地逆转，使用while循环实现。  
  45. LINK_NODE *reverse_local_loop(LINK_NODE *head);  
  46.   
  47. //原地逆转，使用递归实现。  
  48. LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre);  
  49.   
  50. //选择排序，从小到大。  
  51. LINK_NODE *SelectSort(LINK_NODE *head);  
  52.   
  53. //插入排序，从小到大。         
  54. LINK_NODE *InsertSort(LINK_NODE *head);  
  55.   
  56. //冒泡排序，从小到大。  
  57. LINK_NODE *BubbleSort(LINK_NODE *head);  
  58.   
  59. #endif  
#ifndef _SINGLE_LINKEDLIST_H_
#define _SINGLE_LINKEDLIST_H_

#define TRUE       1
#define FALSE      0

//定义结点数据结构
typedef struct _LINK_NODE  
{  
    int data;  
    struct _LINK_NODE* next;  
}LINK_NODE; 


//创建一个结点
LINK_NODE* create_node(int value);

//删除整个链表，pNode为链表头。
void delete_list(LINK_NODE** pNode); 

//使用递归的方法，在链表的末尾加上一个新的结点
int add_node(const LINK_NODE** pNode, int value);

//使用递归的方法，删除数据内容为value的结点
int delete_node(LINK_NODE** pNode, int value);

//查找结点，返回数据内容为value的结点地址，没有找到返回NULL
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value);

//把从pLinkNode结点开始到链表结束的结点个数统计出来
//一般pLinkNode链表头
int count_list(const LINK_NODE *pLinkNode);

//把从pLinkNode结点开始到链表结束的数据全部打印出来
//一般pLinkNode为链表头
void print_list(const LINK_NODE *pLinkNode); 

//新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
LINK_NODE *reverse_new_loop(LINK_NODE *head);

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre);

//原地逆转，使用while循环实现。
LINK_NODE *reverse_local_loop(LINK_NODE *head);

//原地逆转，使用递归实现。
LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre);

//选择排序，从小到大。
LINK_NODE *SelectSort(LINK_NODE *head);

//插入排序，从小到大。       
LINK_NODE *InsertSort(LINK_NODE *head);

//冒泡排序，从小到大。
LINK_NODE *BubbleSort(LINK_NODE *head);

#endif


    main.c文件代码

 

 

[objc] view plain copy
 
 
print?
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3.   
  4. #include "single_linkedlist.h"  
  5.   
  6. int main(int argc, charchar **argv)  
  7. {  
  8.     LINK_NODE *head;  
  9.     LINK_NODE *reverse1, *reverse2;  
  10.       
  11.     head = create_node(1);      
  12.     add_node((const LINK_NODE **)&head, 5);  
  13.     add_node((const LINK_NODE **)&head, 2);  
  14.     add_node((const LINK_NODE **)&head, 4);  
  15.     add_node((const LINK_NODE **)&head, 3);    
  16.       
  17.     printf("=======原始链表head ");    
  18.     print_list(head);  
  19.       
  20.       
  21.     //逆转生成一个新的链表，循环实现  
  22.     reverse1 = reverse_new_loop(head);  
  23.     printf("=======head逆转成的链表reverse1 ");  
  24.     print_list(reverse1);      
  25.       
  26.     //逆转生成一个新的链表，递归实现  
  27.     reverse2 = reverse_new_recursive(head, NULL);  
  28.     printf("=======head逆转成的链表reverse2 ");  
  29.     print_list(reverse2);  
  30.   
  31.     //本地逆转，循环实现          
  32.     reverse1 = reverse_local_loop(reverse1);  
  33.     printf("=======reverse1本地逆转成的链表reverse1 ");  
  34.     print_list(reverse1);      
  35.       
  36.     //本地逆转，递归实现  
  37.     reverse2 = reverse_local_loop(reverse2);  
  38.     printf("=======reverse2本地逆转成的链表reverse2 ");  
  39.     print_list(reverse2);  
  40.       
  41.     //选择排序  
  42.     head = SelectSort(head);  
  43.     printf("=======head选择排序后的链表 ");  
  44.     print_list(head);      
  45.       
  46.     //插入排序  
  47.     reverse1 = InsertSort(reverse1);  
  48.     printf("=======reverse1插入排序后的链表 ");  
  49.     print_list(reverse1);  
  50.   
  51.     //冒泡排序  
  52.     reverse2 = BubbleSort(reverse2);    
  53.     printf("=======reverse2冒泡排序后的链表 ");  
  54.     print_list(reverse2);  
  55.   
  56.     delete_list(&head);  
  57.     delete_list(&reverse1);  
  58.     delete_list(&reverse2);  
  59.                    
  60.     return 0;  
  61. }  
#include <stdio.h>
#include <stdlib.h>

#include "single_linkedlist.h"

int main(int argc, char **argv)
{
    LINK_NODE *head;
    LINK_NODE *reverse1, *reverse2;
    
    head = create_node(1);    
    add_node((const LINK_NODE **)&head, 5);
    add_node((const LINK_NODE **)&head, 2);
    add_node((const LINK_NODE **)&head, 4);
    add_node((const LINK_NODE **)&head, 3);  
    
    printf("=======原始链表head
");  
    print_list(head);
    
    
    //逆转生成一个新的链表，循环实现
    reverse1 = reverse_new_loop(head);
    printf("=======head逆转成的链表reverse1
");
    print_list(reverse1);    
    
    //逆转生成一个新的链表，递归实现
    reverse2 = reverse_new_recursive(head, NULL);
    printf("=======head逆转成的链表reverse2
");
    print_list(reverse2);

    //本地逆转，循环实现        
    reverse1 = reverse_local_loop(reverse1);
    printf("=======reverse1本地逆转成的链表reverse1
");
    print_list(reverse1);    
    
    //本地逆转，递归实现
    reverse2 = reverse_local_loop(reverse2);
    printf("=======reverse2本地逆转成的链表reverse2
");
    print_list(reverse2);
    
    //选择排序
    head = SelectSort(head);
    printf("=======head选择排序后的链表
");
    print_list(head);    
    
    //插入排序
    reverse1 = InsertSort(reverse1);
    printf("=======reverse1插入排序后的链表
");
    print_list(reverse1);

    //冒泡排序
    reverse2 = BubbleSort(reverse2);  
    printf("=======reverse2冒泡排序后的链表
");
    print_list(reverse2);

    delete_list(&head);
    delete_list(&reverse1);
    delete_list(&reverse2);
                 
    return 0;
}


    Makefile文件代码

 

 

[objc] view plain copy
 
 
print?
    1. CC       = gcc  
    2. WORKDIR  =   
    3. INCLUDES =   
    4. LIBS     =  
    5. LINKS    =  
    6. TARGET   = main  
    7.   
    8. src=$(wildcard *.c ./callback/*.c)  
    9. C_OBJS=$(patsubst %.c, %.o,$(src))  
    10. #C_OBJS=$(dir:%.c=%.o)  
    11.   
    12. compile:$(TARGET)  
    13.       
    14. $(C_OBJS):%.o:%.c  
    15.     $(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c  
    16.       
    17. $(TARGET):$(C_OBJS)  
    18.     $(CC) -o $(TARGET) $^ $(LIBS) $(LINKS)   
    19.   
    20.     @echo   
    21.     @echo Project has been successfully compiled.  
    22.     @echo  
    23.       
    24. install: $(TARGET)  
    25.     cp $(TARGET) $(INSTALL_PATH)  
    26.   
    27. uninstall:  
    28.     rm -f $(INSTALL_PATH)/$(TARGET)  
    29.   
    30. rebuild: clean compile  
    31.   
    32. clean:  
    33.     rm -rf *.o  $(TARGET) *.log *~  













以上是关于单向链表的简单使用的主要内容，如果未能解决你的问题，请参考以下文章

双向链表的实现（双向链表与单向链表的简单区别联系和实现）

单向链表的简单使用

简单的单向链表的java实现

单向链表的简单实现

单向链表的创建及其简单功能的实现

数据结构和算法--链表一之单向链表的简单实现