码迷，mamicode.com
首页 > 其他好文 > 详细

单向链表的简单使用

时间：2018-06-20 11:15:47      阅读：173      评论：0      收藏：0      [点我收藏+]

标签：指针成员   list   eve   bee   假设   IV   本地   tail   键值   

一、单向链表的概念

    单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，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\n", pLinkNode->data);    
  5.         print_list(pLinkNode->next);    
  6.     }    
  7. }    
void print_list(const LINK_NODE *pLinkNode)  
{  
    if(pLinkNode) {  
        printf("%d\n", 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\n", 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\n", 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\n");    
  18.     print_list(head);  
  19.       
  20.       
  21.     //逆转生成一个新的链表，循环实现  
  22.     reverse1 = reverse_new_loop(head);  
  23.     printf("=======head逆转成的链表reverse1\n");  
  24.     print_list(reverse1);      
  25.       
  26.     //逆转生成一个新的链表，递归实现  
  27.     reverse2 = reverse_new_recursive(head, NULL);  
  28.     printf("=======head逆转成的链表reverse2\n");  
  29.     print_list(reverse2);  
  30.   
  31.     //本地逆转，循环实现          
  32.     reverse1 = reverse_local_loop(reverse1);  
  33.     printf("=======reverse1本地逆转成的链表reverse1\n");  
  34.     print_list(reverse1);      
  35.       
  36.     //本地逆转，递归实现  
  37.     reverse2 = reverse_local_loop(reverse2);  
  38.     printf("=======reverse2本地逆转成的链表reverse2\n");  
  39.     print_list(reverse2);  
  40.       
  41.     //选择排序  
  42.     head = SelectSort(head);  
  43.     printf("=======head选择排序后的链表\n");  
  44.     print_list(head);      
  45.       
  46.     //插入排序  
  47.     reverse1 = InsertSort(reverse1);  
  48.     printf("=======reverse1插入排序后的链表\n");  
  49.     print_list(reverse1);  
  50.   
  51.     //冒泡排序  
  52.     reverse2 = BubbleSort(reverse2);    
  53.     printf("=======reverse2冒泡排序后的链表\n");  
  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\n");  
    print_list(head);
    
    
    //逆转生成一个新的链表，循环实现
    reverse1 = reverse_new_loop(head);
    printf("=======head逆转成的链表reverse1\n");
    print_list(reverse1);    
    
    //逆转生成一个新的链表，递归实现
    reverse2 = reverse_new_recursive(head, NULL);
    printf("=======head逆转成的链表reverse2\n");
    print_list(reverse2);

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

    //冒泡排序
    reverse2 = BubbleSort(reverse2);  
    printf("=======reverse2冒泡排序后的链表\n");
    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 *~  

单向链表的简单使用

标签：指针成员   list   eve   bee   假设   IV   本地   tail   键值   

原文地址：https://www.cnblogs.com/oneway1990/p/9202572.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！