数据结构--链表基本操作大全（案例实现）建议理解记忆！！！

案例：

主函数（需求）：

int main()
{
    LinkList L;
    int n, i;
    ElemType e;
    if (InitList_L(L))
        cout << "初始化线性表成功" << endl;
    else
    {
        cout << "初始化线性表失败" << endl;
        return 1;
    }
    cout << "输入线性表的元素个数：";
    cin >> n;
    if (n > 0) {
        ElemType* a = new ElemType[n];
        cout << "输入线性表的数据元素：";
        for (int i = 0; i < n; i++)
            cin >> a[i];
        if (!CreateList_L(L, a, n)) {
            cout << "线性表创建失败" << endl;
            return 2;
        }
    }
    if (ListEmpty_L(L)) //检验线性表是否为空
        cout << "线性表为空" << endl;
    else {
        cout << "线性表不为空" << endl;
        cout << "线性表的元素个数为" << ListLength_L(L) << endl;//查询线性表中元素个数
        cout << "线性表的元素为：";
        ListTraverse_L(L, DisplayElem); //遍历
        cout << endl;
    }
    //查询指定位序元素
    cout << "请输入要查询的线性表的位序：" << endl;
    cin >> i;
    if (GetElem_L(L, i, e))
        cout << "线性表中第" << i << "个元素为" << e << endl;
    else
        cout << "位序越界" << endl;
    //查询元素在线性表中的位序 
    cout << "请输入要查询的元素：" << endl;//查询指定元素位序
    cin >> e;
    int orderID;
    if (orderID = LocateElem_L(L, e))
        cout << "线性表中元素" << e << "为第" << orderID << "个" << endl;
    else
        cout << "输入元素未在表中" << endl;
    //测试在链表的第i个元素前插入元素e 
    cout << "请输入线性表插入元素的位序及插入元素值：" << endl;//查询指定位序元素
    cin >> i >> e;
    if (ListInsert_L(L, i, e)) {
        cout << "线性表插入元素成功" << endl;
        cout << "线性表中元素个数为" << ListLength_L(L) << endl;//查询线性表中元素个数
        cout << "线性表的元素为：";
        ListTraverse_L(L, DisplayElem);//遍历
        cout << endl;
    }
    else
        cout << "线性表插入元素失败" << endl;
    //删除L中第m个元素 
    if (!ListEmpty_L(L)) {
        cout << "请输入删除元素的位序：" << endl;//查询指定位序元素
        cin >> i;
        if (ListDelete_L(L, i, e)) {
            cout << "线性表删除元素成功" << endl;
            cout << "线性表中元素个数为" << ListLength_L(L) << endl;//查询线性表中元素个数
            cout << "线性表的元素为：";
            ListTraverse_L(L, DisplayElem); //遍历
            cout << endl;
        }
    }
    //删除L中的元素 e
    if (!ListEmpty_L(L)) {
        cout << "请输入删除元素：" << endl;//查询指定位序元素
        cin >> e;
        if (ListDelete_L(L, e)) {
            cout << "线性表删除元素成功" << endl;
            cout << "线性表中元素个数为" << ListLength_L(L) << endl;//查询线性表中元素个数
            cout << "线性表的元素为：";
            ListTraverse_L(L, DisplayElem); //遍历
            cout << endl;
        }
        else
            cout << "删除元素未在表中" << endl;
    }
    //逆置线性表
    InvertList_L(L);
    if (!ListEmpty_L(L)) {
        cout << "线性表已逆置" << endl;
        cout << "线性表中元素个数为" << ListLength_L(L) << endl;//查询线性表中元素个数
        cout << "线性表的元素为：";
        ListTraverse_L(L, DisplayElem); //遍历
        cout << endl;
    }
    //清空线性表 
    ClearList_L(L);
    if (ListEmpty_L(L)) {
        cout << "线性表已置空" << endl;
    }
    //销毁线性表 
    DestroyList_L(L);
    cout << "线性表已销毁" << endl;
    return 0;
}

函数实现：

//初始化链表 
bool InitList_L(LinkList& L)
{
    L = new LNode;
    L->next = NULL;
    return true;
}

//正序（尾插法）建立链表L
bool CreateList_L(LinkList& L, ElemType* a, int n)
{
    if (n == 0) return true;
    LNode* p = L, * s = NULL;
    for (int i = 0; i < n; i++)
    {
        s = new LNode;
        if (s == NULL)
        {
            ErrorMessage("内存不足!");
            return false;
        }
        s->data = a[i];
        p->next = s;
        p = s;
    }
    p->next = NULL;
    return true;
}

//判断链表L是否为空 
bool ListEmpty_L(LinkList& L)
{
    if (L->next)
        return true;
    else return false;
    //return !(L->next);
}

// 求链表L的长度
int ListLength_L(LinkList L)
{
    LNode* p = L->next;
    int i = 0;
    while (p)
    {
        p = p->next;
        i++;
    }
    return i;
}

//遍历链表L
void ListTraverse_L(LinkList L, void(*func)(ElemType))
{
    LNode* p = L->next;
    while (p)
    {
        (*func)(p->data);
        p=p->next;
    }
}

//查找链表的第m个元素，不存在返回false
bool GetElem_L(LinkList L, int i, ElemType &e)
{
    if (i < 1) return false;
    LNode* p = L->next;
    int n = 1;
    while (p && n < i)
    {
        n++;
        p = p->next;
    }
    if (p)
    {
        e = p->data;
        return true;
    }
    else
        return false;
}

//查找元素e的位序，不存在返回0
int LocateElem_L(LinkList L, ElemType e)
{
    if (L->next == NULL) return 0;
    LNode* p = L->next;
    int i = 1;
    while (p && p->data != e)
    {
        p = p->next;
        i++;
    }
    if (p)
        return i;
    else return 0;
}

//在链表的第m个结点之前插入值为e的元素
bool ListInsert_L(LinkList& L, int m, ElemType e)
{
    LNode* s = new LNode;
    if (s == NULL)
    {
        ErrorMessage("内存不足!");
        return false;
    }
    s->data = e;
    LNode* p = L;
    int j = 0;
        while (p && j < m - 1)
        {
            p = p->next;
            j++;
        }
    if (!p || j > m - 1)
    {
        ErrorMessage("位序越界!");
        return false;
    }
    s->next = p->next;
    p->next = s;
    return true;
}

//删除链表L的第m个元素，其值赋给e。
bool ListDelete_L(LinkList& L, int m, ElemType& e)
{
    LNode* p = L;
    int j = 0;
    while (p->next && j < m - 1)
    {
        p = p->next;
        j++;
    }
    if (!(p->next) || j > m - 1)
        return false;
    LNode* q = p->next;
    e = q->data;
    delete p;
    return true;
}

//删除链表L中值为e的元素
bool ListDelete_L(LinkList& L, ElemType e)
{
    LNode* p = L->next, *q=L;
    while (p && p->data != e)
    {
        q = p;
        p = p->next;
    }
    if (p == NULL) return false;
    q->next = p->next;
    delete p;
    return true;
}

//清空线性表
void ClearList_L(LinkList& L)
{
    LNode* p = L->next, * q;
    while (p)
    {
        q = p->next;
        delete p;
        p = q;
    }
    L->next = NULL;
}

//销毁线性表
void DestroyList_L(LinkList& L)
{
    LNode* p;
    while (L)
    {
        p = L;
        L = L->next;
        delete p;
    }
}

//逆置链表
void InvertList_L(LinkList& L)
{
    if (L->next == NULL || L->next->next == NULL)
        return;
        LNode* p = L->next;
        LNode* q;
    L->next = NULL;
    while (p)
    {
        q = p;
        p = p->next;
        q->next = L->next;
        L->next = q;
    }
}

//ErrorMessage()的实现
void ErrorMessage(const char* mess)
{
    cout << mess << endl;
}
//DisplayElem()的实现
void DisplayElem(ElemType e)
{
    cout << e << ' ';
}

运行结果:

本文为链表的基本操作，所包含的算法很全面！