单链表的定义、插入

不带头结点

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode,*LinkList;

bool InitList(LinkList &L)
{
    L=NULL;
    return true;
}

void test()
{
    LinkList L;
    InitList(L);
    //...后续代码
}

判断是否为空表

bool empty(LinkList L)
{
    if(L=NULL)
    {
        return true;
    }else{
        return false;
    }
}
    

或者直接

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

 

带头结点的单链表

typedef struct LNode
{
    int 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;
}

void test()
{
    LinkList L;    //声明一个指向单链表的指针
    InitList(L)；    //初始化一个空表
    //...

}

判断链表是否为空：

bool empty(LinkList L)
{
    if(L->next==NULL)
    {
        return true;
    }else{
        return false;
    }
}

按位序插入（带头结点）

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode,*LinkList;

//在第i个位置插入元素e（带头结点）
bool InsertList(LinkList &L,int i,int e)
{
    if(i<1)    //判断从第几个节点插入，是否符合要求
        return false;
    LNode* p;    //创建一个指针指向头当前扫描到的节点
    int j=0;        //指针当前指向的是第几个节点
    p=L;        //指针p指向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;    //将节点s连接到p后
    return ture;    //插入成功
}

 

按位序插入（不带头节点）

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode,*LinkList;

bool InsertList(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=1;
    p=L;
    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;
}
    
        

指定节点的后插操作

typedef struct LNode
{
    int data;
    struct LNode* next;
}LNode,*LinkList;

bool InsertNextNode(LNode* p,int e)
{
    LNode* s=(LNode*)malloc(sizeof(LNode));
    if(s==NULL)
        return false;
    s->data=e;
    s->next=p->next;
    p->next=s;

    return true;
}

bool InsertList(LinkList &L,int i,int e)
{
    if(i<1)
        return false;
    LNode* p;
    int j=0;
    p=L;
    while(p!==NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    return InsertNextNode(p,e);
}

指定节点的前插操作

bool InsertPriorNode(LNode* p,LNode* s)
{
    if(p==NULL || s=NULL)
        return false;
    s->next=p->next;
    p->next=s;
    int tmp=p->data;    //交换数据域部分
    
    p->data=s->data;
    s->data=tmp;

    return true;
}