碼上歡樂
相關內容    簡體    繁體

單向鏈表的簡單使用

本文轉載自   查看原文   2018-06-20 10:34   1453 

一、單向鏈表的概念

    單向鏈表是鏈表的一種，其特點是鏈表的鏈接方向是單向的，對鏈表的訪問要通過順序讀取從頭部開始。鏈表是使用指針進行構造的列表，並且是由一個個結點組裝起來的，因此又稱為結點列表。其中每個結點都有指針成員變量指向列表中的下一個結點，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 *~  


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 簡單的單向鏈表的java實現 單向鏈表 單向鏈表 鏈表（二）：單向鏈表 使用單向鏈表保存大量數據的基礎程序框架 單向鏈表（單鏈表）的Java實現 使用java的循環單向鏈表解決約瑟夫問題 單向循環鏈表 Java 單向鏈表學習 單向鏈表的基本操作
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM