单向链表的简单使用

一、单向链表的概念

单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。链表是使用指针进行构造的列表，并且是由一个个结点组装起来的，因此又称为结点列表。其中每个结点都有指针成员变量指向列表中的下一个结点，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. pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));
  5. pLinkNode->data = value;
  6. pLinkNode->next = NULL;
  7. return pLinkNode;
  8. }
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. return _add_node(&(*pNode)->next, pDataNode);
  8. }
  9. int add_node(const LINK_NODE** pNode, int value)
  10. {
  11. LINK_NODE *pDataNode;
  12. if(NULL == *pNode) {
  13. return FALSE;
  14. }
  15. pDataNode = create_node(value);
  16. if(pDataNode == NULL) {
  17. return FALSE;
  18. }
  19. return _add_node((LINK_NODE**)pNode, pDataNode);
  20. }
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. if(NULL == (*pNode)->next) {
  5. return FALSE;
  6. }
  7. pLinkNode = (*pNode)->next;
  8. if(value == pLinkNode->data) {
  9. (*pNode)->next = pLinkNode->next;
  10. free(pLinkNode);
  11. return TRUE;
  12. } else {
  13. return _delete_node(&(*pNode)->next, value);
  14. }
  15. }
  16. int delete_node(LINK_NODE** pNode, int value)
  17. {
  18. LINK_NODE* pLinkNode;
  19. if(NULL == pNode || NULL == *pNode) {
  20. return FALSE;
  21. }
  22. if(value == (*pNode)->data) {
  23. pLinkNode = *pNode;
  24. *pNode = pLinkNode->next;
  25. free(pLinkNode);
  26. return TRUE;
  27. }
  28. return _delete_node(pNode, value);
  29. }
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. if(value == pLinkNode->data)
  7. return (LINK_NODE*)pLinkNode;
  8. return find_node(pLinkNode->next, value);
  9. }
//查找结点，返回数据内容为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. return 1 + count_list(pLinkNode->next);
  7. }
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. if(NULL == pNode || NULL == *pNode) {
  5. return ;
  6. }
  7. pNext = &(*pNode)->next;
  8. free(*pNode);
  9. delete_list(pNext);
  10. }
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. while(head != NULL)
  6. {
  7. p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
  8. if(p1 == NULL) {
  9. p2->next = NULL;
  10. } else {
  11. p2->next = p1;
  12. }
  13. p1 = p2;
  14. p2->data = head->data;
  15. head = head->next;
  16. }
  17. return p1;
  18. }
//新建一条链表，新的链表是原来链表的逆转，使用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. new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
  7. new->next = pre;
  8. new->data = head->data;
  9. if(p) {
  10. return reverse_new_recursive(p, new);
  11. } else {
  12. return new;
  13. }
  14. }
//新建一条链表，新的链表是原来链表的逆转，使用递归实现。
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. if(NULL == head) {
  7. return head;
  8. }
  9. p = head->next;
  10. head->next = NULL;
  11. while(NULL != p) {
  12. tmp = p->next;
  13. p->next = head;
  14. head = p;
  15. p = tmp;
  16. }
  17. return head;
  18. }
//原地逆转，使用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. head->next = pre;
  6. if(p) {
  7. return reverse_local_recursive(p, head);
  8. } else {
  9. return head;
  10. }
  11. }
//原地逆转，使用递归实现。
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. first = NULL;
  10. while (head != NULL)
  11. {
  12. //在剩余的原链表中找出最小值
  13. for (p = head, min = head; p->next != NULL; p = p->next) {
  14. if (p->next->data < min->data) {
  15. premin = p;
  16. min = p->next;
  17. }
  18. }
  19. //将找出来最小值放到新的链表
  20. if (first == NULL) {
  21. first = min;
  22. tail = min;
  23. } else {
  24. tail->next = min;
  25. tail = min;
  26. }
  27. //将找出来的最小值从原来的链表中脱离
  28. if (min == head) {
  29. head = head->next;
  30. } else {
  31. premin->next = min->next;
  32. }
  33. }
  34. if (first != NULL) {
  35. tail->next = NULL;
  36. }
  37. head = first;
  38. return head;
  39. }
//选择排序，从小到大。
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. first = head->next;
  9. head->next = NULL;
  10. while (first != NULL)
  11. {
  12. //找到要插入的位置，p是q的前驱。
  13. for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);
  14. //无序链表中的节点离开，以便它插入到有序链表中。
  15. first = first->next;
  16. if (q == head) {
  17. head = t;  //插在第一个节点之前
  18. } else {
  19. p->next = t;
  20. }
  21. t->next = q;
  22. }
  23. return head;
  24. }
//插入排序，从小到大。
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. p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
  9. p1->next = head;
  10. head = p1;
  11. for (endpt = NULL; endpt != head; endpt = p) {
  12. for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
  13. if (p1->next->data > p1->next->next->data) {
  14. p2 = p1->next->next;
  15. p1->next->next = p2->next;
  16. p2->next = p1->next;
  17. p1->next = p2;
  18. p = p1->next->next;
  19. }
  20. }
  21. }
  22. p1 = head;
  23. head = head->next;
  24. free(p1);
  25. p1 = NULL;
  26. return head;
  27. }
//冒泡排序，从小到大。
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. #include "single_linkedlist.h"
  4. //创建一个结点
  5. LINK_NODE* create_node(int value)
  6. {
  7. LINK_NODE *pLinkNode = NULL;
  8. pLinkNode = (LINK_NODE *)malloc(sizeof(LINK_NODE));
  9. pLinkNode->data = value;
  10. pLinkNode->next = NULL;
  11. return pLinkNode;
  12. }
  13. //使用递归的方法，在链表的末尾加上一个新的结点
  14. int _add_node(LINK_NODE** pNode, LINK_NODE* pDataNode)
  15. {
  16. if(NULL == *pNode) {
  17. *pNode = pDataNode;
  18. return TRUE;
  19. }
  20. return _add_node(&(*pNode)->next, pDataNode);
  21. }
  22. int add_node(const LINK_NODE** pNode, int value)
  23. {
  24. LINK_NODE *pDataNode;
  25. if(NULL == *pNode) {
  26. return FALSE;
  27. }
  28. pDataNode = create_node(value);
  29. if(pDataNode == NULL) {
  30. return FALSE;
  31. }
  32. return _add_node((LINK_NODE**)pNode, pDataNode);
  33. }
  34. //使用递归的方法，删除数据内容为value的结点
  35. int _delete_node(LINK_NODE** pNode, int value)
  36. {
  37. LINK_NODE* pLinkNode;
  38. if(NULL == (*pNode)->next) {
  39. return FALSE;
  40. }
  41. pLinkNode = (*pNode)->next;
  42. if(value == pLinkNode->data) {
  43. (*pNode)->next = pLinkNode->next;
  44. free(pLinkNode);
  45. return TRUE;
  46. } else {
  47. return _delete_node(&(*pNode)->next, value);
  48. }
  49. }
  50. int delete_node(LINK_NODE** pNode, int value)
  51. {
  52. LINK_NODE* pLinkNode;
  53. if(NULL == pNode || NULL == *pNode) {
  54. return FALSE;
  55. }
  56. if(value == (*pNode)->data) {
  57. pLinkNode = *pNode;
  58. *pNode = pLinkNode->next;
  59. free(pLinkNode);
  60. return TRUE;
  61. }
  62. return _delete_node(pNode, value);
  63. }
  64. //查找结点，返回数据内容为value的结点地址，没有找到返回NULL.
  65. LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)
  66. {
  67. if(NULL == pLinkNode)
  68. return NULL;
  69. if(value == pLinkNode->data)
  70. return (LINK_NODE*)pLinkNode;
  71. return find_node(pLinkNode->next, value);
  72. }
  73. //把从pLinkNode结点开始到链表结束的结点个数统计出来
  74. //一般pLinkNode链表头
  75. int count_list(const LINK_NODE *pLinkNode)
  76. {
  77. if(NULL == pLinkNode) {
  78. return 0;
  79. }
  80. return 1 + count_list(pLinkNode->next);
  81. }
  82. //把从pLinkNode结点开始到链表结束的数据全部打印出来
  83. //一般pLinkNode为链表头
  84. void print_list(const LINK_NODE *pLinkNode)
  85. {
  86. if(pLinkNode) {
  87. printf("%d\n", pLinkNode->data);
  88. print_list(pLinkNode->next);
  89. }
  90. }
  91. //删除整个链表，pNode为链表头。
  92. void delete_list(LINK_NODE** pNode)
  93. {
  94. LINK_NODE** pNext;
  95. if(NULL == pNode || NULL == *pNode) {
  96. return ;
  97. }
  98. pNext = &(*pNode)->next;
  99. free(*pNode);
  100. delete_list(pNext);
  101. }
  102. //新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
  103. LINK_NODE *reverse_new_loop(LINK_NODE *head)
  104. {
  105. LINK_NODE *p1 = NULL, *p2;
  106. while(head != NULL)
  107. {
  108. p2 = (LINK_NODE *) malloc(sizeof(LINK_NODE));
  109. if(p1 == NULL) {
  110. p2->next = NULL;
  111. } else {
  112. p2->next = p1;
  113. }
  114. p1 = p2;
  115. p2->data = head->data;
  116. head = head->next;
  117. }
  118. return p1;
  119. }
  120. //新建一条链表，新的链表是原来链表的逆转，使用递归实现。
  121. LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre)
  122. {
  123. LINK_NODE *p = head->next;
  124. LINK_NODE *new;
  125. new = (LINK_NODE *) malloc(sizeof(LINK_NODE));
  126. new->next = pre;
  127. new->data = head->data;
  128. if(p) {
  129. return reverse_new_recursive(p, new);
  130. } else {
  131. return new;
  132. }
  133. }
  134. //原地逆转，使用while循环实现。
  135. LINK_NODE *reverse_local_loop(LINK_NODE *head)
  136. {
  137. LINK_NODE *p;
  138. LINK_NODE *tmp;
  139. if(NULL == head) {
  140. return head;
  141. }
  142. p = head->next;
  143. head->next = NULL;
  144. while(NULL != p) {
  145. tmp = p->next;
  146. p->next = head;
  147. head = p;
  148. p = tmp;
  149. }
  150. return head;
  151. }
  152. //原地逆转，使用递归实现。
  153. LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre)
  154. {
  155. LINK_NODE *p = head->next;
  156. head->next = pre;
  157. if(p) {
  158. return reverse_local_recursive(p, head);
  159. } else {
  160. return head;
  161. }
  162. }
  163. //选择排序，从小到大。
  164. LINK_NODE *SelectSort(LINK_NODE *head)
  165. {
  166. LINK_NODE *first;     /*排列后有序链的表头指针*/
  167. LINK_NODE *tail;      /*排列后有序链的表尾指针*/
  168. LINK_NODE *premin;    /*保留键值更小的节点的前驱节点的指针*/
  169. LINK_NODE *min;       /*存储最小节点*/
  170. LINK_NODE *p;         /*当前比较的节点*/
  171. first = NULL;
  172. while (head != NULL)
  173. {
  174. //在剩余的原链表中找出最小值
  175. for (p = head, min = head; p->next != NULL; p = p->next) {
  176. if (p->next->data < min->data) {
  177. premin = p;
  178. min = p->next;
  179. }
  180. }
  181. //将找出来最小值放到新的链表
  182. if (first == NULL) {
  183. first = min;
  184. tail = min;
  185. } else {
  186. tail->next = min;
  187. tail = min;
  188. }
  189. //将找出来的最小值从原来的链表中脱离
  190. if (min == head) {
  191. head = head->next;
  192. } else {
  193. premin->next = min->next;
  194. }
  195. }
  196. if (first != NULL) {
  197. tail->next = NULL;
  198. }
  199. head = first;
  200. return head;
  201. }
  202. //插入排序，从小到大。
  203. LINK_NODE *InsertSort(LINK_NODE *head)
  204. {
  205. LINK_NODE *first; /*为原链表剩下用于直接插入排序的节点头指针*/
  206. LINK_NODE *t;     /*临时指针变量：插入节点*/
  207. LINK_NODE *p;     /*临时指针变量*/
  208. LINK_NODE *q;     /*临时指针变量*/
  209. first = head->next;
  210. head->next = NULL;
  211. while (first != NULL)
  212. {
  213. //找到要插入的位置，p是q的前驱。
  214. for (t = first, q = head; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);
  215. //无序链表中的节点离开，以便它插入到有序链表中。
  216. first = first->next;
  217. if (q == head) {
  218. head = t;  //插在第一个节点之前
  219. } else {
  220. p->next = t;
  221. }
  222. t->next = q;
  223. }
  224. return head;
  225. }
  226. //冒泡排序，从小到大。
  227. LINK_NODE *BubbleSort(LINK_NODE *head)
  228. {
  229. LINK_NODE *endpt; /*控制循环比较*/
  230. LINK_NODE *p;     /*临时指针变量*/
  231. LINK_NODE *p1;
  232. LINK_NODE *p2;
  233. p1 = (LINK_NODE *)malloc(sizeof(LINK_NODE));
  234. p1->next = head;
  235. head = p1;
  236. for (endpt = NULL; endpt != head; endpt = p) {
  237. for (p = p1 = head; p1->next->next != endpt; p1 = p1->next) {
  238. if (p1->next->data > p1->next->next->data) {
  239. p2 = p1->next->next;
  240. p1->next->next = p2->next;
  241. p2->next = p1->next;
  242. p1->next = p2;
  243. p = p1->next->next;
  244. }
  245. }
  246. }
  247. p1 = head;
  248. head = head->next;
  249. free(p1);
  250. p1 = NULL;
  251. return head;
  252. }
#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. #define TRUE       1
  4. #define FALSE      0
  5. //定义结点数据结构
  6. typedef struct _LINK_NODE
  7. {
  8. int data;
  9. struct _LINK_NODE* next;
  10. }LINK_NODE;
  11. //创建一个结点
  12. LINK_NODE* create_node(int value);
  13. //删除整个链表，pNode为链表头。
  14. void delete_list(LINK_NODE** pNode);
  15. //使用递归的方法，在链表的末尾加上一个新的结点
  16. int add_node(const LINK_NODE** pNode, int value);
  17. //使用递归的方法，删除数据内容为value的结点
  18. int delete_node(LINK_NODE** pNode, int value);
  19. //查找结点，返回数据内容为value的结点地址，没有找到返回NULL
  20. LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value);
  21. //把从pLinkNode结点开始到链表结束的结点个数统计出来
  22. //一般pLinkNode链表头
  23. int count_list(const LINK_NODE *pLinkNode);
  24. //把从pLinkNode结点开始到链表结束的数据全部打印出来
  25. //一般pLinkNode为链表头
  26. void print_list(const LINK_NODE *pLinkNode);
  27. //新建一条链表，新的链表是原来链表的逆转，使用while循环实现。
  28. LINK_NODE *reverse_new_loop(LINK_NODE *head);
  29. //新建一条链表，新的链表是原来链表的逆转，使用递归实现。
  30. LINK_NODE *reverse_new_recursive(LINK_NODE *head, LINK_NODE *pre);
  31. //原地逆转，使用while循环实现。
  32. LINK_NODE *reverse_local_loop(LINK_NODE *head);
  33. //原地逆转，使用递归实现。
  34. LINK_NODE *reverse_local_recursive(LINK_NODE *head, LINK_NODE *pre);
  35. //选择排序，从小到大。
  36. LINK_NODE *SelectSort(LINK_NODE *head);
  37. //插入排序，从小到大。
  38. LINK_NODE *InsertSort(LINK_NODE *head);
  39. //冒泡排序，从小到大。
  40. LINK_NODE *BubbleSort(LINK_NODE *head);
  41. #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. #include "single_linkedlist.h"
  4. int main(int argc, charchar **argv)
  5. {
  6. LINK_NODE *head;
  7. LINK_NODE *reverse1, *reverse2;
  8. head = create_node(1);
  9. add_node((const LINK_NODE **)&head, 5);
  10. add_node((const LINK_NODE **)&head, 2);
  11. add_node((const LINK_NODE **)&head, 4);
  12. add_node((const LINK_NODE **)&head, 3);
  13. printf("=======原始链表head\n");
  14. print_list(head);
  15. //逆转生成一个新的链表，循环实现
  16. reverse1 = reverse_new_loop(head);
  17. printf("=======head逆转成的链表reverse1\n");
  18. print_list(reverse1);
  19. //逆转生成一个新的链表，递归实现
  20. reverse2 = reverse_new_recursive(head, NULL);
  21. printf("=======head逆转成的链表reverse2\n");
  22. print_list(reverse2);
  23. //本地逆转，循环实现
  24. reverse1 = reverse_local_loop(reverse1);
  25. printf("=======reverse1本地逆转成的链表reverse1\n");
  26. print_list(reverse1);
  27. //本地逆转，递归实现
  28. reverse2 = reverse_local_loop(reverse2);
  29. printf("=======reverse2本地逆转成的链表reverse2\n");
  30. print_list(reverse2);
  31. //选择排序
  32. head = SelectSort(head);
  33. printf("=======head选择排序后的链表\n");
  34. print_list(head);
  35. //插入排序
  36. reverse1 = InsertSort(reverse1);
  37. printf("=======reverse1插入排序后的链表\n");
  38. print_list(reverse1);
  39. //冒泡排序
  40. reverse2 = BubbleSort(reverse2);
  41. printf("=======reverse2冒泡排序后的链表\n");
  42. print_list(reverse2);
  43. delete_list(&head);
  44. delete_list(&reverse1);
  45. delete_list(&reverse2);
  46. return 0;
  47. }
#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. src=$(wildcard *.c ./callback/*.c)
    8. C_OBJS=$(patsubst %.c, %.o,$(src))
    9. #C_OBJS=$(dir:%.c=%.o)
    10. compile:$(TARGET)
    11. $(C_OBJS):%.o:%.c
    12. $(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c
    13. $(TARGET):$(C_OBJS)
    14. $(CC) -o $(TARGET) $^ $(LIBS) $(LINKS)
    15. @echo
    16. @echo Project has been successfully compiled.
    17. @echo
    18. install: $(TARGET)
    19. cp $(TARGET) $(INSTALL_PATH)
    20. uninstall:
    21. rm -f $(INSTALL_PATH)/$(TARGET)
    22. rebuild: clean compile
    23. clean:
    24. rm -rf *.o  $(TARGET) *.log *~

原文地址：https://www.cnblogs.com/oneway1990/p/9202572.html

时间： 2024-08-14 10:02:08

单向链表的简单使用的相关文章

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

链表在我们java中也是一种基础的数据结构,可以理解成是一种和数组同级的数组结构,正如我们所知,在我们使用这集合ArrayList和LinkedList的时候,总会学习底层数组实现的ArrayList和双向链表实现的LinkedList的区别.在这里,我们将要讲说的是单向链表的简单实现,让我们体会一下链表在实现增删改查的时候是怎么样的一个操作,在和前边涉及到的数组的增删改查进行对比,得到我们学习的结论,数组的增删效率低于链表结构,查改效率高于链表结构! 什么叫做单向链表,我们可以理解为一个一个节

单向链表的简单实现

一.概念 单向链表是一种简单数据结构,由多个节点构成,每个节点里面保存了节点中的数据和指向下一个节点的引用,链表的第一个节点被称为根节点(root)或头节点(head) 二.使用Java实现基本结构 需要一个Node类和一个Link类,Node类中存放Node中保存的数据和下一个Node的指向,Link类中保存root节点. 1 class Node { 2 private String data; 3 private Node next; 4 public Node(String data)

单向链表的简单Java实现-sunziren

写在前面,csdn的那篇同名博客就是我写的,我把它现在在这边重新发布,因为我实在不想用csdn了,那边的广告太多了,还有就是那个恶心人的"阅读更多"按钮,惹不起我躲得起. 最近面试的过程中,发现有的公司的面试题考到了链表的逆序,这一块我正好不是特别清楚.于是打算把链表这一块好好的学习学习.在网上搜寻了众多的资料以后,了解到链表的核心是节点与节点之间的互相链接. 于是自己也写了一个单向链表的类,里面包括input插入方法,inputById按指定下标插入方法,deleteAll删除所有节

单向链表的Java实现

一.链表的简单实现 1 package test01; 2 3 /* 4 * 单向链表的简单实现 5 * */ 6 7 class Node{ 8 private String data; 9 private Node next; 10 public Node(String data){ 11 this.data = data; 12 } 13 public String getData() { 14 return data; 15 } 16 public void setData(String

C语言实现简单的单向链表（创建、插入、删除）及等效STL实现代码

实现个算法,懒得手写链表,于是用C++的forward_list,没有next()方法感觉很不好使,比如一个对单向链表的最简单功能要求: input: 1 2 5 3 4 output: 1->2->5->3->4 相当于仅仅实现了插入.遍历2个功能(当然遍历功能稍微修改就是销毁链表了) 用纯C写了份测试代码 /* 基本数据结构的定义以及函数的声明 */ typedef int ElemType; typedef struct Node { ElemType elem; struc

文章分享：简单数据结构学习：单向链表

文章分享:简单数据结构学习:单向链表:https://www.textarea.com/aprikyb/jiandan-shujujiegou-xuexi-danxiang-lianbiao-252/

C#学习单向链表和接口 IList&lt;T&gt;

作者:乌龙哈里 时间:2015-11-04 平台:Window7 64bit,Visual Studio Community 2015 参考: MSDN 索引器(C# 编程指南) <数据结构(C#语言版)>下载 When to use IEnumerable, ICollection, IList and List 章节: 单向链表元素 定义单向链表操作接口 逐步实现单向链表 正文: 前面学习了 IEnumerable<T>.IComparable<T>.ICollec

python数据结构链表之单向链表

本文和大家分享的主要是python中单向链表相关内容,一起来看看吧,希望对大家学习python有所帮助. 单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域.这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值. ． 表元素域elem用来存放具体的数据. ． 链接域next用来存放下一个节点的位置(python中的标识) ． 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点. 节点实现 class 

java版的单向链表的逆序输出

将单向链表逆序输出,方法有三种: a.遍历链表,将每个节点的内容存入一个数组中,然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出(本文采用的方法) 先介绍算法: 1). 若链表为空或只有一个元素,则直接返回: 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继: 3). 重复2),直到q为空 4). 调整链表头和链表尾 示例:以逆序A->B->C->D为例,图示如下 package com.moluo.shujujiegou;