C语言 单链表 相关操作

数据结构 单链表

若有错误还请指出

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

typedef struct LNode{        //定义单链表结点类型 
    int data;                //每个节点存放一个数据元素 
    struct LNode *next;        //指针指向下一个结点    
}LNode,*LinkList;

//判断不带头结点的单链表是否为空
bool Empty1(LinkList L){
    return (L==NULL);
} 

//初始化不带头结点的单链表
bool InitList1(LinkList &L){
    L=NULL;                    //空表，暂时还没有任何节点 
    return true;
} 

//判断带头结点的单链表是否为空
bool Empty2(LinkList L){
    if(L->next ==NULL)
        return true;
    else
        return false;
} 

//初始化带头结点的单链表    头结点不存储数据 
bool InitList2(LinkList &L){
    
    L=(LNode *)malloc(sizeof(LNode));        //分配一个头结点     
    if(L==NULL)                                //内存不足，分配失败 
        return false;
    L->next = NULL;                            //头结点之后暂时还没有节点 
    return true;
} 

//插入操作(带头结点)(按位)    最好时间复杂度O(1)    最差时间复杂度O(n)    平均时间复杂度O(n) 
bool ListInsert2(LinkList &L,int i,int e){
    if(i<1)                                    
        return false;
    LNode *p;                                //指针p指向当前扫描到的结点 
    int j=0;                                //当前p指向的是第几个结点，可以把头结点看做是第0个结点 
    p=L;                                    //L指向头结点，头结点是第0个结点，但是不存储数据 
    while(p!=NULL && j<i-1){                //循环找到第i-1个结点 
        p=p->next;
        j++; 
    }
    if(p==NULL)                                //i的值不合法 
        return false;
    LNode *s = (LNode *)malloc (sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true; 
} 

//插入操作(不带头结点)(按位)    最好时间复杂度O(1)    最差时间复杂度O(n)    平均时间复杂度O(n) 
bool ListInsert1(LinkList &L,int i,int e){
    if(i<1)                                    
        return false;
    if(i==1){                                //插入第一个结点的操作与其它结点操作不同 
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data=e;
        s->next=L;
        L=s;                                //头指针指向新结点 
        return true; 
    } 
    LNode *p;                                //指针p指向当前扫描到的结点 
    int j=1;                                //当前p指向的是第几个结点
    p=L;                                    //L指向第一个结点
    while(p!=NULL && j<i-1){                //循环找到第i-1个结点 
        p=p->next;
        j++; 
    }
    if(p==NULL)                                //i的值不合法 
        return false;
    LNode *s = (LNode *)malloc (sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true; 
} 

//后插操作:在p结点之后插入元素e     O(1)
bool InsertNextNode(LNode *p,int e){
    
    if (p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;                    //内存分配失败
    s->data=e;                            //用结点s保存数据元素e 
    s->next=p->next;
    p->next=s;                            //将结点s连接到p之后 
    return true; 
} 

//前插操作:在p结点之前插入元素    O(1)
bool InsertPriorNode(LNode *p,int e){
    
    if(p==NULL)
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if(s==NULL)
        return false;                    //内存分配失败
    
    s->next=p->next;
    p->next=s;                            //新节点s连接到p之后 
    s->data=p->data;                    //将p中元素复制到s中 
    p->data=e;                            //p中元素覆盖为e 
    return true; 
} 

//按位序删除(带头节点)        最好时间复杂度O(1)    最差时间复杂度O(n)    平均时间复杂度O(n) 
bool ListDelete(LinkList &L,int i,int &e){
    
    if(i<1)
        return false;
    LNode *p;                            //指针p指向当前扫描到的结点
    int j=0;                            //当前指针p指向的是第几个结点
    p=L;                                //L指向头结点
    
    while(p!=NULL && j<i-1){            //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    if(p==NULL)
        return false;
    if(p->next == NULL)
        return false;
    
    LNode *q=p->next;                    //令Q指向被删除的结点
    e = q->data;                        //用e返回元素的值
    p->next = q->next;                    //将*q结点从链中断开 
    free(q);                            //释放结点的存储空间 
    return true; 
} 

//删除指定结点p 该方法存在问题，若删除最后一个结点会报错，暂时先用着，考试的时候可能会扣一分左右 
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNode *q=p->next;                    //令q指向*p的后继结点 
    p->data=p->next->data;                //和后继结点交换数据域 
    p->next=q->next;                    //将*q结点从链中断开 
    free(q);                            //释放后继结点的存储空间 
    return true;
} 

//按位查找 带头结点 
LNode *GetElem(LinkList L,int i){
    
    if(i<0)
        return NULL;
    LNode *p;                    //指针p指向当前扫描到的结点 
    int j=0;                    //当前p指向的是第几个结点 
    p=L;                        //L指向头结点 
    while(p!=NULL && j<i){        //循环找到第i个结点 
        p=p->next;
        j++;
    } 
    return p;
} 

//按值查找 带头结点
LNode * LocateElem(LinkList L,int e){
    
    LNode *p=L->next;
    while(p!=NULL && p->data != e)
        p=p->next;
    return p;
} 
 

int main(){
    return 0;
} 

 补充一下头插法和尾插法

//尾插法建立单链表
LinkList List_TailInsert(LinkList &L){    
    int x;                                    //结点的data 
    L=(LinkList)malloc(sizeof(LNode));        //建立头结点
    LNode *s,*r=L;                            //r为表尾指针
    scanf("%d",&x);                            //输入结点的值 
    while(x!=9999){                            //输入9999表示结束 
        
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x); 
    } 
    r->next=NULL;
    return L;
} 

//头插法建立单链表
LinkList List_HeadInsert(LinkList &L){

    LNode *s;
    int x;
    L=(LinkList)malloc(sizeof(LNode));        //创建头结点 
    L->next=NULL;                            //初始为空链表 
    scanf("%d",&x);                            //输入结点的值 
    while(x!=9999){
        
        s=(LNode *)malloc(sizeof(LNode));        //创建新结点 
        s->data=x;
        s->next=L->next;
        L->next=s;                            //将新节点插入表中，L为头指针 
        scanf("%d",&x); 
    } 
    return L;
}