单链表学习代码

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

bool InitList(LinkList &L)//不带头结点单链表的初始化 
{
    L=NULL;//空表，暂时还没有任何数据 防止读脏数据 
    return true;
}

bool Empty(LinkList L)
{
    return (L==NULL);
 } 

void test()
{
    LinkList L;
    InitList(L);
 } 
 
 //带头结点的单链表
typedef struct LNode{//定义单链表结点类型 
    ElemType data;//数据域 每个结点存放一个数据元素 
    struct LNode* next;//指针域 指向下一个结点 
}LNode,*LinkList; 

bool InitList(LinkList &L)//不带头结点单链表的初始化 
{
    L=(LNode*)malloc(sizeof(LNode));//创建一个头结点
    if(L==NULL)//内存不够，分配失败 
    {
        return false;
    }
    L->next=NULL; 
    return true;
}

bool Empty(LinkList L)
{
    return (L->next==NULL);
 } 

void test()
{
    LinkList L;//声明一个指向单链表的指针
    InitList(L);//初始化一个单链表 
 } 
 
//按位序插入(带头结点) 时间复杂度O(n) 
typedef struct LNode{//定义单链表结点类型 
    ElemType data;//数据域 每个结点存放一个数据元素 
    struct LNode* next;//指针域 指向下一个结点 
}LNode,*LinkList; 
//在第i个位置插入元素e 
bool ListInsert(LinkList &L,int i,int e)
{
    if(i<1){
        return false;
    }
    LNode* p;//指针p用于指向当前扫描到的结点
    p=L;//p指向头结点 ，头结点是第0结点，不存数据 
    int j =0; //当前p指向的是第几个结点
    if(p==NULL)//i值不合法 
    {
        return false;
     } 
     while(p!=NULL && j<i-1){//循环找到第i-1个结点 
         p=p->next;
         j++;
     }
     LNode* s = (LNode*)malloc(sizeof(LNode));
     s->data=e;
     s->next=p->next;
     p->next=s;//将s结点连到p结点之后 
     return true;//插入成功 
      
 } 
 
//按位序插入（不带头结点）
typedef struct LNode{//定义单链表结点类型 
    ElemType data;//数据域 每个结点存放一个数据元素 
    struct LNode* next;//指针域 指向下一个结点 
}LNode,*LinkList; 
//在第i个位置插入元素e 

bool ListInsert(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;//指向当前扫描到的节点
    int j=0;//表示当前指向的是第几个结点
    p=L;//p指向第一个结点（不是头结点）
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
     } 
     if(p==NULL)
     {
         return false;
     }
     LNode* s = (LNode*)malloc(sizeof(LNode));
     s->data=e;
     s->next=p->next;
     p->next=s;
     return true;
     
}

//指定结点的后插操作 时间复杂度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->next=p->next;
    p->next=s;
    return true; 
}
//指定结点的前插操作
bool InsertPriorNode(LNode* p,int e)
{
    if(p==NULL)
    {
        return false;
    }
    LNode* s = (LNode*)malloc(sizeof(LNode));
    s->next=p->next; 
    p->next=s;
    s->data=p->data;
    p->data=e;
    return true;
}

//按位序删除(带头结点)
typedef struct LNode{//定义单链表结点类型 
    ElemType data;//数据域 每个结点存放一个数据元素 
    struct LNode* next;//指针域 指向下一个结点 
}LNode,*LinkList; 

bool ListDelete(LinkList &L,int i,int &e)
{
    if(i<1)
    {
        return false;
    }
    LNode* p;
    int j = 0;
    p=L;
    if(p==NULL)
    {
        return false;
    }
    while(p!=NULL&&j<i-1)//循环找到第i-1个结点 
    {
        p=p->next;
        j++;
    }
    if(p->next==NULL)//第i-1个结点后已无其他结点 
    {
        return false;
    }
    LNode* q = p->next;// 令q指向被删除的结点 
    e=q->data;//用e返回元素的值 
    p->next=q->next;//将*p结点从链表中断开 
    free(q); //释放结点的存储空间 
    return true;
 } 
 //按位序删除(不带头结点)
typedef struct LNode{//定义单链表结点类型 
    ElemType data;//数据域 每个结点存放一个数据元素 
    struct LNode* next;//指针域 指向下一个结点 
}LNode,*LinkList; 

bool ListDelete(LNode* p,int i,int &e)
{
    if(i<1)
    {
        return false;
    }
    if(i==1)
    {
        LNode* q = L;
        e=q->data;
        L=q->next;
        free(q);
    }
    LNode* p;
    int j =0;
    p=L;
    while(p!=NULL&&j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    if(p->next==NULL)
    {
        return false;
    }
    LNode* q = p->next;
    e=q->data;
    p->next=q->next;
    free(q);
    return true;
 } 

//指定结点的删除
bool ListDelete(LNode* p)
{
    if(p==NULL)
    {
        return false;
    }
    LNode* q = p->next;
    q->data=p->data;
    p->next=q->next;
    free(q);
    return true;    
 } 
 
//求表长操作
int ListLength(LinkList L)
{
    LNode* p=L;
    int length=0;
    while(p->next!NULL)
    {
        p=p->next;
        length++;
    }
    return length;
 } 

//按序号查找结点
LNode* GetElem(LinkList L,int i)
{
    LNode* p =L;
    int j =0;
    while(p!=NULL&&j<i)
    {
        p=p->next;
        j++;
    }
    return p;
 }
 
//按值查找结点
LNode* LocateElem(LinkList L,ElemType e)
{
    LNode* p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
        
    }
    return p;
 } 
 
//尾插法建立单链表
LinkList List_TailInsert(LinkList &L)//正向建立单链表 
{
    int x;//设元素类型为整型
    L=(LNode*)malloc(sizeof(LNode));//创建头结点
    L->next=NULL;//初始为空链表 
    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 
        r=s;//r指向新的表尾结点 
        scanf("%d",&x);
     } 
     r->next=NULL;//尾结点指针置空 
     return L; 
 } 
 
//头插法建立单链表
LinkList List_HeadInsert(LinkList &L)
{
    int x;//设置元素类型为整型
    LNode* s; 
    L=(LNode*)malloc(sizeof(LNode));//创建头结点
    L->next=NULL;//初始为空链表 
    scanf("%d",&x);//输入结点的值
    while(x!=9999)//输入9999表示结束 
    {
        s=(LNode*)malloc(sizeof(LNode));//创建新结点 
        s->data=x;
        s->next=L->next;
        L->next=s;//将新结点插入表中 
        scanf("%d",&x);
         
    }
    return L; 
 } 

//双链表的初始化(带头结点)
typedef struct DNode{//定义一个双链表结点类型 
    ElemType data;// 数据域 
    struct DNode *prior,*next;//指针域 
}DNode,*DLinkList; 

bool InitList(DLinkList &L)
{
    L = (DNode*)malloc(sizeof(DNode));//创建头结点
    if(L==NULL)
    {
        return false;//内存不足，分配失败 
     } 
     L->prior=NULL;//头结点的prior永远指向NULL 
     L->next=NULL; //头结点之后暂时还没有结点
     return true; 
 } 

bool Empty(DLinkList L)
{
  return (L->next==NULL);
 } 
 
void testDLinkList(){
    //声明一个双链表 
    DLinkList L;
    InitDLinkList(L);     //初始化双链表
} 

//双链表的插入
//在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s)
{
    if(p==NULL||s==NULL)
    {
        return false;
    }
    s->next=p->next;
    if(p->next!=NULL)
    {
        p->next->prior=s;
    }
    s->prior=p;
    p->next=s;
    return true;
 } 
 
//双链表的删除
//删除p结点的后继结点 
bool DeleteDNode(LNode* p)
{
    if(p==NULL)
    {
        return false;
    }
    DNode *q =p->next;
    if(q==NULL)
    {
        return false;
    }
    p->next=q->next;
    if(q->next!=NULL)
    {
        q->next->prior=p;
    }
     free(p);
     return true;
    
 } 
 
void DestoryList(DLinkList &L)
{
    //循环释放各个结点
    while(L->next!=NULL)
    {
        DeleteNextDNode(L);
     } 
     free(L);//释放头结点
     L=NULL; 
}