链表操作 （C语言）插入，合并，销毁，删除，冒泡排序

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>


typedef struct Node{
    int data;
    struct Node *next;
}node;//把node 声明为struct Node.


node *add(node *head,int data);
node *ListDelete(node *head,int i);
node *reverse(node *head);
node *buddleSort(node *head);
node *mergeList(node *head1,node *head2,node *head3);


void listDestroy(node *head);
void print(node *head);
int length1(node *head);




int main()
{
    node *head1 = NULL;
    node *head2 = NULL;
    node *head3 = NULL;
    int i = 10;
    while(i-- > 0)
    {
        head1 = add(head1,rand()%100);
        head2 = add(head2,rand()%100);
    }


    buddleSort(head1);
    buddleSort(head2);


    print(head1);
    print(head2);


    head3 = mergeList(head1,head2,head3);
    print(head3);


    head3 = reverse(head3);
    print(head3);


    //listDestroy(head1);
    //listDestroy(head2);
    listDestroy(head3);


    return 1;
}


//合并两个基本有序的链表，到head3
node *mergeList(node *head1,node *head2,node *head3)
{
    node *tail = NULL;
    if(head1==NULL)
    {
        head3 = head2;
        return head3;
    }
    else if(head2==NULL)
    {
        head3 = head1;
        return head3;
    }
    else
    {
        if(head1->data > head2->data)
        {
            head3 = head2;
            tail = head3;
            head2 = head2->next;
        }
        else
        {
            head3 = head1;
            tail = head3;
            head1 = head1->next;
        }
    }
    while(head1&&head2)
    {
        if(head1->data > head2->data)
        {
            tail->next = head2;
            tail = head2;
            head2 = head2->next;
        }
        else
        {
            tail->next = head1;
            tail = head1;
            head1 = head1->next;
        }
    }
    tail ->next = head1 ? head2 : head1;//插入剩余段。


    return head3;
}


//用头插完成链表的反转。
node * reverse(node *head)
{
    node * tempHead = NULL,*p=NULL;
    while(head)
    {
        p = head;
        head = head -> next;
        p->next = tempHead;
        tempHead = p;
    }
    return tempHead;
}


//对链表冒泡排序 升序
node *buddleSort(node *head)
{
    int len = length1(head);
    node *p1 =head,*p2=head,*tempFinish=NULL;
    while(len-- > 0)
    {
        p1 = p2 = head;
        while(p2!=tempFinish)
        {
            p2=p2->next;


            if(p2==NULL)
                break;


            else if(p1->data > p2->data)
            {
                p1->data = (p1->data)^(p2->data);
                p2->data = (p1->data)^(p2->data);
                p1->data = (p1->data)^(p2->data);
            }
            p1 = p2;
        }
        tempFinish = p1;
    }
    return head;
}


//添加一个元素
node * add(node *head,int data)
{
    node *p = NULL;
    if(head==NULL)
    {
        head = (node*)malloc(sizeof(node));
        head->data = data;
        head->next = NULL;
    }
    else
    {
        p = (node*)malloc(sizeof(node));
        p->data = data;
        p->next = head;
        head = p;
    }
    return head;
}


//删除一个元素
node * ListDelete(node *head,int i)
{
    node *p1,*p2;
    if(i>length1(head))
        printf("删除位置不正确！");
    else
    {
        p1 = head;
        if(i==0)
        {
            head = head->next;
            free(p1);
        }


        else
        {
            while(--i > 0)
            {
                p1 = p1->next;
            }
            p2 = p1->next;
            p1->next = p1->next->next;
            free(p2);
        }


    }
    return head;
}


//销毁链表
void listDestroy(node*head)
{
    node *p = head;
    print(head);
    while(head!=NULL)
    {
        head = head->next;
        free(p);
        p = head;
    }
}


//查看链表长度
int length1(node *head)
{
    node *p = head;
    unsigned int len=0;
    while(p!=NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}


//打印链表数据
void print(node *head)
{
    while(head!=NULL)
    {
        printf("%d ",head->data);
        head = head -> next;
    }
    printf("\n");
}