Detailed explanation of single linked list implementation in C++

1. Define the structure of the linked list

//设计理念：把指针封装起来，减少在外层调用时对指针的操作
typedef struct LNode
{
       elemtype data;
       struct LNode *next;//疑问
}LNode,*LinkList;//储存一个数据，存储下一个指针
//*linklist数组头指针，制定了这个链表的地址
//利用了typedef 的特性，用Linklist代替了（struct Lnode *），直接获取指针

 2. Initialize the linked list

//利用了typedef 的特性，用Linklist代替了（struct Lnode *），直接获取指针
void InitList(LinkList &L)
{   //L = (struct Lnode *)malloc(sizeof(LNode));
    L = (LinkList)malloc(sizeof(LNode));
    L ->next = NULL;
}

 3. Table creation by head insertion method and table creation by tail insertion method

Head insertion method 

//头插法建表
void CreateList_H(LinkList &L,int n)
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = n;i>0;--i)//++i与--i单独使用无区别，但--i效率更高
    {
        LinkList s = (LinkList)malloc(sizeof(LNode));
        cin>>s->data;
        s->next = L->next;
        L->next = s;
    }
}

tail insertion method

//尾插法建表
void CreateList_H(LinkList &L,int n)
{
    LinkList tail = L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = n;i>0;--i)
    {
        LinkList s = (LinkList)malloc(sizeof(LNode));
        cin>>s->data;
        tail->next = s;
        tail = s;    
    }
}

4. Destroy the linked list 

 

//销毁线性表
void DestroyList(LinkList &L)
{
    LinkList p = L,q=p->next;
    while (q!=NULL)
    {
        free(p);
        p = q;q = p->next;
    }
    free(p);
}

5. Insert nodes

//插入
stadus ListInsert(LinkList &L,int i,elemtype e)
{
    LinkList p = L;
    int j = 0;
    while (p&&j<i-1)
    {
        p = p->next;
        j++;
    }//把p指针指向插入的位置,定位操作，并且当p指向空时，会停止，且最终j等于i-1
    if(!p||j>i-1)
        return error;//越界处理
    //主要操作
    LinkList s = (LinkList)malloc(sizeof(LNode));//申请一个节点
    s->data = e;//数据给到s的数据位
    s->next = p->next;//s的数据位指向p下一个节点的地址
    p->next = s;//p的地址位指向s
    return ok;
}

6. Delete nodes 

//删除
stadus listDelete(LinkList &L,int i,elemtype &e)//把删掉的数据保存在引用中
{
    LinkList p = L;int j = 0;
    while(p->next&&j<i-1)
    {
        p = p->next;
        j++;
    }
    if (!(p->next)||j>i-1) return error;
    LinkList t = p->next;
    e = t->data;
    p->next = p->next->next;
    free(t);
    return ok;
}

7. Find location by data

//按元素查找位置
int LocateElem(LinkList L,elemtype e)
{
    LinkList p = L->next;
    int n = 1;
    while((p!= NULL)&& (p->data !=e))
    {
        p = p->next;
        n++;
    }
    if(p==NULL)
        return 0;
    else 
        return n;
}

 8. Other operations

//判断是否为空表
int ListEmpyt(LinkList L)
{
    return(L->next == NULL);
}
//求线性表长度
int ListLength(LinkList L)
{
    LinkList p = L;
    int i =0;
    while (p->next!= NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}
//输出线性表篇
void DispList(LinkList L)
{
    LinkList p =L->next;
    while (p!=NULL)
    {
        cout<<p->data;
        p = p->next;
    }
}
//取表元素
stadus getItem(LinkList L,int i,elemtype &e)
{
    LinkList p = L->next;
    int j =1;
    while(p&&j<i){
        p = p->next;
        j++;
    }
    if(!p||j>i)
        return 0;
    e = p->data;
    return 1;
}

9. Complete code

#include <iostream>
using namespace std;
typedef int elemtype;
typedef int stadus;
//设计理念：把指针封装起来，减少在外层调用时对指针的操作
typedef struct LNode
{
       elemtype data;
       struct LNode *next;//疑问
}LNode,*LinkList;//储存一个数据，存储下一个指针
//*linklist数组头指针，制定了这个链表的地址
//利用了typedef 的特性，用Linklist代替了（struct Lnode *），直接获取指针
void InitList(LinkList &L)
{   //L = (struct Lnode *)malloc(sizeof(LNode));
    L = (LinkList)malloc(sizeof(LNode));
    L ->next = NULL;
}
//销毁线性表
void DestroyList(LinkList &L)
{
    LinkList p = L,q=p->next;
    while (q!=NULL)
    {
        free(p);
        p = q;q = p->next;
    }
    free(p);
}
//判断是否为空表
int ListEmpyt(LinkList L)
{
    return(L->next == NULL);
}
//求线性表长度
int ListLength(LinkList L)
{
    LinkList p = L;
    int i =0;
    while (p->next!= NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}
//输出线性表篇
void DispList(LinkList L)
{
    LinkList p =L->next;
    while (p!=NULL)
    {
        cout<<p->data;
        p = p->next;
    }
}
//取表元素
stadus getItem(LinkList L,int i,elemtype &e)
{
    LinkList p = L->next;
    int j =1;
    while(p&&j<i){
        p = p->next;
        j++;
    }
    if(!p||j>i)
        return 0;
    e = p->data;
    return 1;
}

//插入
stadus ListInsert(LinkList &L,int i,elemtype e)
{
    LinkList p = L;
    int j = 0;
    while (p&&j<i-1)
    {
        p = p->next;
        j++;
    }//把p指针指向插入的位置,定位操作，并且当p指向空时，会停止，且最终j等于i-1
    if(!p||j>i-1)
        return error;//越界处理
    //主要操作
    LinkList s = (LinkList)malloc(sizeof(LNode));//申请一个节点
    s->data = e;//数据给到s的数据位
    s->next = p->next;//s的数据位指向p下一个节点的地址
    p->next = s;//p的地址位指向s
    return ok;
}

//删除
stadus listDelete(LinkList &L,int i,elemtype &e)//把删掉的数据保存在引用中
{
    LinkList p = L;int j = 0;
    while(p->next&&j<i-1)
    {
        p = p->next;
        j++;
    }
    if (!(p->next)||j>i-1) return error;
    LinkList t = p->next;
    e = t->data;
    p->next = p->next->next;
    free(t);
    return ok;
}
//头插法建表
void CreateList_H(LinkList &L,int n)
{
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = n;i>0;--i)//++i与--i单独使用无区别，但--i效率更高
    {
        LinkList s = (LinkList)malloc(sizeof(LNode));
        cin>>s->data;
        s->next = L->next;
        L->next = s;
    }
}
//尾插法建表
void CreateList_H(LinkList &L,int n)
{
    LinkList tail = L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = n;i>0;--i)
    {
        LinkList s = (LinkList)malloc(sizeof(LNode));
        cin>>s->data;
        tail->next = s;
        tail = s;    
    }
}
//按元素查找位置
int LocateElem(LinkList L,elemtype e)
{
    LinkList p = L->next;
    int n = 1;
    while((p!= NULL)&& (p->data !=e))
    {
        p = p->next;
        n++;
    }
    if(p==NULL)
        return 0;
    else 
        return n;
}
//节约空间，读取慢于顺序表；插入删除方便，就是地址的切换与覆盖
//动态分配内存，避免浪费