单向链表的简单使用

来源：互联网发布：怎样抢注域名编辑：程序博客网时间：2024/04/30 10:10

一、单向链表的概念

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

结点的数据结构

typedef struct _LINK_NODE  {      int data;      struct _LINK_NODE* next;  }LINK_NODE;

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

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

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

三、单向链表的基本操作

1、建立一个新的链表

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、增加一个结点（增加到末尾）

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、删除一个结点

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、查找结点

//查找结点，返回数据内容为value的结点地址，没有找到返回NULLLINK_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、统计结点个数

int count_list(const LINK_NODE *pLinkNode)  {      if(NULL == pLinkNode) {          return 0;      }             return 1 + count_list(pLinkNode->next);  }

6、打印整个链表

void print_list(const LINK_NODE *pLinkNode)  {      if(pLinkNode) {          printf("%d\n", pLinkNode->data);          print_list(pLinkNode->next);      }  }

7、删除整个链表

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、逆转并生成新的链表（非递归方式）

//新建一条链表，新的链表是原来链表的逆转，使用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、逆转并生成新的链表（递归方式）

//新建一条链表，新的链表是原来链表的逆转，使用递归实现。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、原地逆转，不生成新链表（非递归方式）

//原地逆转，使用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、原地逆转，不生成新链表（递归方式）

//原地逆转，使用递归实现。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,然后它变成其尾指针

//选择排序，从小到大。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）从原链表中依次取结点，插入到有序链表的相应位置，使得有序链表仍然有序，直至原链表的结点全部取完，排序结束。

//插入排序，从小到大。       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、冒泡排序

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

//冒泡排序，从小到大。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文件代码

#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文件代码

#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的结点地址，没有找到返回NULLLINK_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文件代码

#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文件代码

CC       = gccWORKDIR  = INCLUDES = LIBS     =LINKS    =TARGET   = mainsrc=$(wildcard *.c ./callback/*.c)C_OBJS=$(patsubst %.c, %.o,$(src))#C_OBJS=$(dir:%.c=%.o)compile:$(TARGET)$(C_OBJS):%.o:%.c$(CC) $(CFLAGS) $(INCLUDES) -o $*.o -c $*.c$(TARGET):$(C_OBJS)$(CC) -o $(TARGET) $^ $(LIBS) $(LINKS) @echo @echo Project has been successfully compiled.@echoinstall: $(TARGET)cp $(TARGET) $(INSTALL_PATH)uninstall:rm -f $(INSTALL_PATH)/$(TARGET)rebuild: clean compileclean:rm -rf *.o  $(TARGET) *.log *~

0 0