同时创建两条单链表，头插法插入节点，遍历，查找，删除，求长度，冒泡排序，反转，2条有序链表链接成一条链表后依然有序

#include <stdio.h>
#include <stdlib.h>
/*
链表每日一练：创建2条空链表，头插法插入节点，遍历，查找，删除，求长度，冒泡排序，反转，2条有序链表链接成一条链表后依然有序。
*/
typedef struct node
{
    int data;
    struct node * next;
}NODE;
//创建空链表
NODE * createList()
{
    NODE * head = (NODE *)malloc(sizeof(NODE));
    head->next = NULL;

    return head;
}
//头插法插入节点
void insertNode(NODE *head,int insertData)
{
    NODE *sur = (NODE *)malloc(sizeof(NODE));
    sur->data = insertData;

    sur->next = head->next;
    head->next = sur;
}
//遍历
void traverList(NODE *head)
{
    head = head->next;
    while(head)
    {
        printf("%d
",head->data);
        head = head->next;
    }
}
//查找
NODE * lookNode(NODE *head,int lookData)
{
    head = head->next;
    while(head)
    {
        if(head->data == lookData)
            break;
        else
            head = head->next;
    }
    return head;
}
//删除
void deleteNode(NODE *head,NODE *p)
{
    while(head->next != p)
        head = head->next;
    head->next = p->next;
    free(p);
}
//求长度
int lenList(NODE * head)
{
    int len = 0;
    head = head->next;
    while(head)
    {
        len++;
        head = head->next;
    }

    return len;
}
//冒泡排序
void Popsort(NODE *head,int len)
{
    int i,j;
    NODE * sur = NULL;
    NODE *p,*q,*temp;
    p = q = temp = NULL;
    for(i = 0;i<len-1;i++)
    {
        sur = head;
        p = sur->next;
        q = p->next;
        for(j = 0;j<len-i-1;j++)
        {
            if(p->data > q->data)
            {
                sur->next = q;
                p->next = q->next;
                q->next = p;

                temp = q;
                q = p;
                p = temp;
            }
            sur = sur->next;
            p = p->next;
            q = q->next;
        }
    }
}
//链表反转，分2步：1,先将原有链表分成2个链表，一个是空链表，一个是无头结点的链表
//                   2.然后将无节点的链表逐个插入至空链表中
//步骤1：差分链表
NODE *breakList(NODE *head)
{
    NODE * p = head->next;
    head->next = NULL;

    return p;
}
//插入
void ReverList(NODE *head,NODE *p)
{
    while(p)
    {
        NODE * q = p->next;
        p->next = head->next;
        head->next = p;
        p = q;
    }    
}
//合并链表,合并后使之仍然有序
NODE * mergeList(NODE *head1,NODE *head2)
{
    NODE * sur = createList();
    head1 = head1->next;
    head2 = head2->next;
    while(head1&&head2)
    {
        if(head1->data >= head2->data)//特别注意这一点：链表头插法从小到大输出，实际上插入结点的时候，是先把最大的插进链表
                                      //最后吧最小的插进链表。和数组正好是反的。即：数组从前往后放，头插链表从后往前放。
        {
            insertNode(sur,head1->data);
            head1 = head1->next;
        }
        else
        {    
            insertNode(sur,head2->data);
            head2 = head2->next;
        }
    }
    if(NULL == head1)
    {
        while(head2)
        {
            insertNode(sur,head2->data);
            head2 = head2->next;
        }
    }
    else
    {
        while(head1)
        {
            insertNode(sur,head1->data);
            head1 = head1->next;
        }
    }
    return sur;
}    
int main(void)
{
    //创建2条空链表
    NODE * head1 = createList();
    NODE * head2 = createList();
    //头插法插入节点
    for(int i = 0;i<50;i++)
        insertNode(head1,rand()%100);
    for(i = 1;i<60;i += 2)
        insertNode(head2,i);
    //遍历链表
    traverList(head1);
    printf("-------链表2------------
");
    traverList(head2);
    printf("------查找99这个结点---------
");
    //链表查找,如果找到返回该结点指针，否则返回NULL
    NODE * plook1 = lookNode(head1,99);
    NODE * plook2 = lookNode(head2,99);
    //执行删除操作
    if(plook1)
        deleteNode(head1,plook1);
    if(plook2)
        deleteNode(head2,plook2);
    printf("------删除后链表-------1
");
    traverList(head1);
    printf("------------删除后链表2----------
");
    traverList(head2);
    //链表冒泡排序
    printf("-----------链表排序--------
");
    int len1 = lenList(head1);
    int len2 = lenList(head2);
    Popsort(head1,len1);
    Popsort(head2,len2);
    printf("-------链表1------------
");
    traverList(head1);
    printf("-------链表2------------
");
    traverList(head2);
    printf("------链表1反转-------
");
    NODE *Newhead1 = breakList(head1);
    NODE *Newhead2 = breakList(head2);
    ReverList(head1,Newhead1);
    traverList(head1);
    printf("------链表2反转-------
");
    ReverList(head2,Newhead2);
    traverList(head2);
    printf("------合并2条有序的链表，使之合并后仍然有序-------
");
    traverList(mergeList(head1,head2));

    return 0;
}