反转链表提高（包含链表其他的常用操作） 附详细的注释和要注意的细节

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
/*反转链表*/

/*定义一个节点*/
typedef struct node{
    int data;
    struct node *next;
}Node;

/*将节点插入链表  用于后面创建一个链表*/
void insertList(Node * head,int data)
{
    /* 分配内存 */
    Node *cur = (Node *)malloc(sizeof(Node));
    /*打断原有的联系 让待插入的节点有所指向  head->next = NULL;  */
    cur->data = data;
    cur->next = head->next;
    /*进行插入操作*/
    head->next = cur;
}
/*将链表逆转   头插法*/
void reverseList(Node *head)
{
    Node *next_of_tep;
    /*将链表从头节点开始一分为二*/
    Node *tep = head->next;
    head->next = NULL;

    /*每次操作大概流程：先保留第二条链表的头的next
      再断开第二条链表的头和后面的连接（指向null-->也就是所谓的有所指向）*/
    while(tep)
    {
        /*先将源链表中，tep->next保存起来（next_of_tep）。用这个来标记，下一次头插的*/
        next_of_tep = tep->next;

        /*切断原有连接*/
        tep->next = head->next;
        head->next = tep;
        /*以上两步，完成一次头插*/

        /*准备写一次头插*/
        /*每一次头插，都是插在tep前面；所以要将tep赋值成 新插进来的节点。下一个节点插在新插的节点之前*/
        tep = next_of_tep;
    }
}
/*遍历链表函数*/
void travelList(Node *head)
{
    head = head->next;  /*第一个节点是空的，所以直接指向空头节点的后一个*/
    while(head) /*判断是否为空（每个节点的下一个节点如果为NULL，则链表到头）*/
    {
        printf("%d    ",head->data);
        head = head->next;
    }
}
/*查找*/
/*返回值：要找数据对应的节点*/
Node * searchList(Node *head,int data)
{
    /*因为头节点是空，不用查*/
    head = head->next;
    while(head)
    {
        if(head->data == data)
            break;
        head = head->next;
    }
    /*找到了，返回的就是节点的地址；没有找到，返回的就是最后一个节点的指向NULL*/
    return head;
}
/*删除节点*/
void delectList(Node * head,Node *delNode)
{
    /*方法一：用遍历的方式。这个方法的核心：找前驱 */
//    while(head->next != delNode )
//    {
//        head = head->next;
//    }
//    /*改变链表的连接及结构*/
//    head->next = delNode->next;
//    /*删除节点*/
//    free(delNode);

    /*方法二：直接删除节点  但是这个方法不适合没有后继的结点*/
    /*定义一个节点 ，用来保存原始的 delNode->next ；因为最后要删除 delNode->next
      如果不保存，删除的就不是原始的 delNode->next ，而是改动以后的delNode->next*/
//    Node *tep = delNode->next;
//    delNode->data = tep->data;
//    delNode->next = tep->next;
//    free(tep);
    /*方法三：将上述两种方式结合*/
    if(delNode->next == NULL) /*没有后继，用方法一（遍历）*/
    {
        while(head->next != delNode )
        {
            head = head->next;
        }
        /*改变链表的连接及结构*/
        head->next = delNode->next;
        /*删除节点*/
        free(delNode);
    }
    else                    /*有后继，用方法二*/
    {
        Node *tep = delNode->next;
        delNode->data = tep->data;
        delNode->next = tep->next;
        free(tep);
    }
}
/*查询链表长度   遍历
返回值：链表的长度(不包括头节点)*/
int lenList(Node *head)
{
    int i=0;
    head = head->next;
    while(head)
    {
        i++;
        head = head->next;
    }
    return i;
}
/*排序  利用冒泡法*/
void popSortList(Node *head)
{
    /*方式1：交换数据*/
//    int i,j,len=0;
//    Node *tep,*tep_behind;
//    /*获取链表的长度，用作循环的上限*/
//    len = lenList(head);
//    for(i=0;i<len-1;i++)
//    {
//        /*不包括头节点*/
//        tep = head->next;
//        tep_behind = tep->next;
//        for(j=i;j<len-i-1;j++)
//        {
//            if(tep->data > tep_behind->data)
//            {
//                tep->data        ^= tep_behind->data;
//                tep_behind->data ^= tep->data;
//                tep->data        ^= tep_behind->data;
//            }
//            tep = tep->next;
//            tep_behind = tep->next;
//        }
//    }


    /*方式2：交换指针*/
    int i,j,len=0;
    Node *per,*tep,*tep_behind;
    /*获取链表的长度，用作循环的上限*/
    len = lenList(head);
    for(i=0;i<len-1;i++)
    {
        /*每次需要改变第三个节点的指向，所以定义三个节点*/
        /*三个节点的初始化*/
        per = head;
        tep = per->next;
        tep_behind = tep->next;
        for(j=i;j<len-i-1;j++)
        {
            if(tep->data > tep_behind->data)
            {
                /*三个，节点交换   交换的时候，注意交换的先后顺序*/
                per->next = tep_behind;
                tep->next = tep_behind->next;
                tep_behind->next = tep;

                /*移动完以后，节点对应的位置要转换，然后移动。为了下次的移动*/
                per = tep_behind;
                tep_behind = tep->next;
                continue;
            }
            /*如果没有交换，三个节点顺次即可*/
            per = per->next;
            tep = per->next;
            tep_behind = tep_behind->next;
        }
    }
}
/*链表的销毁*/
/*核心思想：从头到尾一个个的删除*/
void destroyList(Node *head)
{
    /*不能直接free节点，要先将节点信息保存。否则free一次以后，无法继续free*/
    Node *tep;
    while(head)
    {
        tep = head->next;
        free(head);
        head = tep;
    }
}

int main(void)
{
    int i;/*用来循环的随机数*/
    Node * ret_node;/*接受返回的节点*/
    /*创建一个空链表   带头节点的*/
    Node * head = (Node *)malloc(sizeof(Node));
    head->next = NULL;

    /*创建一个链表  借助插入函数*/
    srand(time(NULL));
    for(i=0;i<10;i++)
    insertList(head,rand()%10);

    /*排序*/
    popSortList(head);
    /*构造遍历函数，借助遍历函数输出链表中每个节点的值*/
    travelList(head);

    printf("\n");
    /*将链表逆转   头插法*/
    reverseList(head);
    travelList(head);

    /*查找*/
    ret_node = searchList(head,5);

    /*删除节点*/
    delectList(head,ret_node);
    printf("\n");
    travelList(head);

    /*销毁*/
    destroyList(head);

    return 0;
}