动态链表创建、删除、插入、排序

#include
#include
#define stu struct Student
#define LEN sizeof(stu)
struct Student{
     
    int ID;
    stu *next;
};
stu *creat();//创建动态链表
void print(stu *head);//输出动态链表
stu *del(stu *head,int n);//删除节点
stu *ins(stu *head,int n,int after);//插入节点
stu *sort1(stu *head);//链表排序1
stu *sort2(stu *head);//链表排序2
int main()
{
     
    stu *p=creat();
    int num,num1,num2;
    
    /*测试creat和print函数*/
    print(p);
    puts("");
    
    /*测试del函数*/
    scanf("%d",&num);
    print(del(p,num));
    
    /*测试ins函数*/
    scanf("%d%d",&num1,&num2);
    print(ins(p,num1,num2));
    
    /*测试sort1和sort2函数*/
    print(sort2(p));
    print(sort1(p));
    return 0;
}
stu *creat()
{
     
    stu *head=NULL,*p1,*p2;
    int n=0;
    p1=p2=(stu *)malloc(LEN);
    scanf("%d",&p1->ID);
    while(p1->ID!=0){
     
        n++;
        if(n==1) head=p1;
        else p2->next=p1;
        p2=p1;
        p1=(stu *)malloc(LEN);
        scanf("%d",&p1->ID);
    }
    p2->next=NULL;
    return head;
}
void print(stu *head)
{
     
    stu *p1;
    for(p1=head;p1!=NULL;p1=p1->next){
     
        printf("%d ",p1->ID);
    }
}
stu *del(stu *head,int n)
{
     
    stu *p1,*p2;
    if(head->ID==n){
     
        free(head);
        return head->next;
    }
    for(p2=head,p1=head->next;p1!=NULL;p2=p1,p1=p1->next){
     
        if(p1->ID==n){
     
            p2->next=p1->next;
            free(p1);
            return head;
        }
    }
    return NULL;
}
stu *ins(stu *head,int after,int n)
{
     
    stu *p1,*p2;
    for(p1=head;p1!=NULL;p1=p1->next){
     
       if(p1->ID==after){
     
            p2=(stu *)malloc(LEN);
            p2->ID=n;
            p2->next=p1->next;
            p1->next=p2;
            return head;
       }
    }
    return NULL;
}

/*通过改变节点连接逻辑交换节点*/
stu *sort1(stu *head)
{
     
    stu *p1,*p2,*p3,*p4;
    for(p1=head;p1->next!=NULL;p3=p1,p1=p1->next){
     
        for(p2=p1->next;p2!=NULL;p4=p2,p2=p2->next){
     
            if(p1->ID>p2->ID){
     
                if(p1==head&&p2==head->next){
     
                    head=p2;
                    p1->next=p2->next;
                    p2->next=p1;
                
                    p1=head;
                    p2=head->next;
                }
                else if(p1==head&&p2!=head->next){
     
                    stu *tp;
                    head=p2;
                    tp=p1->next;
                    p1->next=p2->next;
                    p2->next=tp;
                    p4->next=p1;
                
                    p1=head;
                    p2=p4->next;
                }
                else if(p1!=head&&p2==p1->next){
     
                    stu *tp;
                    p3->next=p2;
                    p1->next=p2->next;
                    p2->next=p1;
            
                    p1=p3->next;
                    p2=(p3->next)->next;
                }
                else{
     
                    stu *tp;
                    p3->next=p2;
                    p4->next=p1;
                    tp=p1->next;
                    p1->next=p2->next;
                    p2->next=tp;
            
                    p1=p3->next;
                    p2=p4->next;
                }
            }
        }
        
    }
    return head;
}

/*通过交换节点内的数据交换节点*/
stu *sort2(stu *head)
{
     
    stu *p1,*p2;
    for(p1=head;p1->next!=NULL;p1=p1->next){
     
        for(p2=p1->next;p2!=NULL;p2=p2->next){
     
            if(p1->ID>p2->ID){
     
                int t;
                t=p1->ID;
                p1->ID=p2->ID;
                p2->ID=t;
            }
        }
    }
    return head;
}