链表插入和删除算法

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

//函数声明
PNODE create_list();//返回值是链表头结点的地址
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
bool insert_list(PNODE,int,int);//此处可以不定义形参，只声明形参类型
bool delete_list(PNODE,int,int *);
void sort_list(PNODE pHead);


typedef struct Node{
    int data;//数据域
    struct Node * pNext;//指针域    
}NODE,*PNODE;//NODE等价于struct Node  PNODE等价于struct Node*

int main(){
    PNODE pHead = NULL;//等价于struct Node * pHead = NULL;
    
    pHead = create_list();//创建一个非循环单链表，并将该链表的头结点的地址赋值给pHead
    
    traverse_list(pHead);//遍历 
    
    sort_list(pHead);//排序
    
    insert_list(pHead,4,33);在第个节点的位置插入数据33
    
    int val;
    if(delete_list(pHead,4,&val)){
//删除第四个节点的数据，并返回删除的数据，由于是直接在地址上操作，所以无需返回值
    printf("删除成功，删除的数据是%d",val);
    }
    else{
        printf("删除失败，数据不存在");
    }
    if(is_empty(pHead)){
        printf("链表为空");
    }
    else{
        printf("链表不空");
    }
     
     int len = length_list(pHead);
     printf("链表长度是%d",len)；
     
     
     
    return 0;
}

PNODE create_list(){
    int len;//有效节点的个数
    int i;
    int val;//临时存放用户输入的结点的值
    
    //分配一个不存放有效数据的头结点
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    if(pHead==NULL){
        printf("分配失败，程序终止");
        exit(-1);
    }
    
     PNODE pTail = pHead;
     pTail->PNext = NULL;//若只有一个结点，此时就为尾节点，指针域应当为空
    printf("链表节点个数：");
    scanf("%d",&len);
    
    for(i=0;i<len;i++){
        printf("请输入第%d个节点的值:",i+1);
        scanf("%d",&val);
        
        PNODE pNew = (PNODE)malloc(sizeof(NODE));//生成新结点
             if(pNew==NULL){
            printf("分配失败，程序终止");
            exit(-1);
        }
        pNew->data = val;//把数据存放进新结点的数据域
        pNew->pNext = NULL;//把新结点指针域赋值为空
        pTail->pNext = pNew;//把新结点地址赋值给尾节点指针域
        pTail = pNew;//最后一步把新结点地址复制给尾节点（就是让新结点成为尾节点）
       // pHead->pNext = pNew;
       // pNew->pNext=NULL;//最后一个结点的指针域为空
    }
    return pHead;
}

void traverse_list(PNODE pHead){
    PNODE p = pHead->pNext;//若链表为空，则头结点指针域就为空，则p就为空
    
    while(p!=NULL){
        printf("%d ",p->data);
        p=p->pNext;
    }
    printf("
");
    return;
}

bool is_empty(PNODE pHead){
    if(pHead->pNext==NULL){//如果头结点的指针域为空，则链表为空
        return true;
    }
    else{
        return false;
    }
}

int length_list(PNODE pHead){
     PNODE p = pHead->pNext;
     int len = 0;
     while(p!=NULL){
         len++;
         p=p->pNext;
     }
}

void sort_list(PNODE pHead){
    int  i ,j , t;
    int len = length_list(pHead);
    PNODE p,q;
    //重点!!!
    for(i=0,p=pHead->pNext; i<len-1; i++,p=p->pNext){
        for(j=j+1,q=p->pNext;j<len;j++,q=q->pNext){
            if(p->data > q->data){ //类似于数组的：a[i]>a[j]
                t = p->data;          //t=a[i];
                p->data = q->data;    //a[i]=a[j];
                q->data = t;          //a[j]=t;  
            }
        }
    }
}

//在pHead所指向链表的第pos个节点前面插入新节点，值是val，pos从1开始
bool insert_list(PNODE pHead,int pos,int val){
    int i = 0;
    PNODE p=pHead;
    
    while(p!=NULL&&i<pos-1){//找到第pos前面一个节点的指针域，所指向的为插入的节点位置
        p=p->pNext;
        i++;
    }
    
    if(i>pos-1||p==NULL){
        return false;
    }
    
    PNODE pNew=(PNODE)malloc(sizeof(NODE));//动态分配内存生成一个新节点
    if(pNew==NULL){
        printf("动态分配内存失败");
        exit(-1);
    }
    //重点
    pNew->data = val;//把数据存放进插入的新结点的数据域
    PNODE q=p->pNext;//临时节点q指向节点p的指针域，即插入新结点之后的节点地址
    p->pNext=pNew;//节点p的指针域指向新节点地址
    pNew->pNext=q;//新结点的指针域指向原来p节点的指针域
    
    return true;
}

bool delete_list(PNODE pHead,int pos,int  *pVal){
    int i = 0;
    PNODE p=pHead;
    
    while(p->pNext!=NULL&&i<pos-1){//找到要删除的第pos个节点之前的节点的指针域
        p=p->pNext;        //假如要删除第五个节点，需要找到第四个节点的指针域，这样就指向了第五个节点
        i++;
    }
    
    if(i>pos-1||p->pNext==NULL){
        return false;
    }
    
     PNODE q=p->pNext;//临时节点q指向即将删除节点的地址(即p节点的指针域指向的节点)，以便最后释放内存地址
     *pVal = q->data;//保存即将删除节点的数据域
     p->pNext=p->pNext->pNext;
//重新使p节点指向p节点之后节点的指针域(p节点后面的节点被删，所以p节点的下一个的下一个节点地址)
     free(q);//释放q节点内存
     q=NULL;
     return true;
}