单向链表的7种基本操作（创建、插入、查找、删除、排序(交换节点)、排序(交换数据)、销毁）代码实现（附详细注释）

代码实现如下：

#include "list.h"
#include <stdio.h>
#include <stdlib.h>

typedef struct _node   /*定义一个节点，节点包含两部分，数据域和指针域*/
{
    int data;                 /*数据域*/
    struct _node * next;      /*指针域*/  /*next指向下一个节点的位置*/
}Node; 
/*创建链表*/  /*带有头结点的链表（带头结点的链表：在对链表中第一个节点进行操作的时候，很重要。eg:交换、删除，插入）*/
Node *createList()
{
   /*这个创建链表，实际上是创建空链表*/
    /*   head：头节点   */
    /* 头指针是指向链表中第一个结点（或为头结点或为首元结点）的指针 */
    /*
     * 头结点指的是链bai表中物理上的第一个结点
       头指针指的是指zhi向物理上第一个结点的指针（存放该结点地址的变量）
       开始结点指的是逻辑上的第一个元素的结点
       一般而言，如果链表没有空的头结点，则头结点就是开始结点
       但是数据结构中为了简化插入删除操作，链表一般都是有空的头结点的，
       这样开始结点就成了事实上（物理上的）第二个结点了
    */
   Node *head =(Node*)malloc(sizeof(Node));
    /*head->next：里面存放的是链表中的第一个元素*/
    head->next = NULL;
    return head;
}
/*将将节点插入链表*/
void insertList(Node * head,int data)
{
    /*先让要插入的的节点有所指向(所谓的指向，就是存储了人家的地址)，这样不会导致数据丢失*/
    /*cur:准备要插入链表的节点，通常，我们用cur表示*/
    Node *cur = (Node*)malloc(sizeof(Node));
    cur->data = data;
    cur->next = head->next;
    /*打断原有的联系，建立新关联*/
    head->next = cur;
}
/*遍历*/
void travereList(Node *head)
{
    /*head：头节点    head->next:下一个节点的地址*/
    /*从链表头开始，执行第一个有效元素*/
    head = head->next;
    while(head)
    {
        printf("%2d \n",head->data);
        /*继续往下传，遍历每一个*/
        head=head->next;
    }
}
/*求表长   这个过程，本身就是一个遍历*/
int lenList(Node *head)
{
    int num=0;
    /*从链表头开始，执行第一个有效元素*/
    head = head->next;
    while(head)
    {
        num++;
        head = head->next;
    }
    return num;
}
/*查找*/
/*
输入参数：头指针
输入参数：要查找的值

返回值：返回找到的节点的指针*/
Node *searchList(Node *head,int find)
{
    /*从链表头开始，执行第一个有效元素*/
    head = head->next;
    while(head)
    {
        if(head->data == find)
            break;
        head = head->next;
    }
    return head;
}
/*删除
输入参数：头指针
输入参数：要查找的前驱
*/
void delectList(Node *head,Node *pfind)
{
//    /*方法  1  用遍历的方式*/
//    /*这个地方，先找到前驱*/
//    while(head->next != pfind)
//    {
//        head = head->next;
//    }
//    head->next = pfind->next;
//    /*删除节点*/
//    free(pfind);

//    /*方法  2
//    实现思路：1）、找到要删除的节点  2）、将后继中的数据，拷贝到这个节点
//    3）、删除他的后继节点*/
//    /*这个方法有一个限制，就是他必须有后继。也就是说，不适合删除最后一个节点的情况*/
//    /*再定义一个节点，用来存放待删除节点的下一个节点。主要是为了方便书写和free*/
//    Node *t = pfind->next;
//    pfind->data = t->data;
//    pfind->next = t->next;
//    free(t);

    /*为了拟补第二种方法缺点，我们将一二种方法合并*/
    if(pfind->next == NULL)
    {
        /*第一种方法*/
            while(head->next != pfind)
            {
                head = head->next;
            }
            head->next = pfind->next;
            /*删除节点*/
            free(pfind);
    }
    else/*第二种方法  不用遍历找前驱*/
    {
        /*再定义一个节点，用来存放待删除节点的下一个节点。主要是为了方便书写和free*/
        Node *t = pfind->next;
        pfind->data = t->data;
        pfind->next = t->next;
        free(t);
    }
}
/*排序  利用冒泡的基本思想
分交换数据和交换指针两种*/
void popSortList(Node *head)
{
//    /*交换数据*/
//    int i,j;
//    Node *p,*q,*f;
//    /*首先知道链表的长度*/
//    int len = lenList(head);
//    /*循环排序*/
//    for(i=0;i<len-1;i++)
//    {
//        p=head->next;
//        q=p->next;
//        for(j=0;j<len-1-i;j++)
//        {
//            if(p->data > q->data)
//            {
//                f->data = q->data;
//                q->data = p->data;
//                p->data = f->data;
//            }
//            p=p->next;
//            q=p->next;
//        }
//    }
      /*交换指针*/
    int i,j,len;
    Node *p,*q,*per;
    len = lenList(head);
    for(i=0;i<len-1;i++)
    {
        per = head;
        p=head->next;
        q=p->next;
        for(j=0;j<len-1-i;j++)
        {
            /*头指针head不能变，因为每次外层循环都要用
            所以，定义指针per,迎来存储每次移动以后，三个节点中，最前面节点的地址*/
           if(p->data > q->data)
           {
               per->next = q;
               p->next = q->next;
               q->next = p;

           /*如果发生了交换，执行交换节点以后的移动*/
               per = q;
               /*交换以后，q在前。所以，移动也应该移动的是q*/
               q = p->next;
               continue;
           }
           /*如果没有发生交换，三个节点顺次后移*/
           per = per->next;
           p   = p->next;
           q   = q->next;
        }
    }
}
/*将链表逆转     头插法的使用*/
void reverseList(Node *head)
{
    Node *t;
    /*将一条链表 变成 两条链表   NULL是链表结束的标志*/
    Node *h = head->next;
    head->next = NULL;

    while(h)
    {
        /*先将h的后继节点存起来  为下一次的头插法做准备*/
        t = h->next;
        /*头插法的核心操作*/
        h->next = head->next;
        head->next = h;
        /*准备下一次头插法*/
        h=t;
    }
}
/*销毁*/
void destroyList(Node *head)
{
    /*从头到尾，一个个的删除*/
    Node *t;
    while(head)
    {
        t=head->next;
        free(head);
        head = t;
    }
}