单链表实现，自己写了关于单链表各种操作的C/C++代码，欢迎大家参考

个人认为单链表最重要的是可以在O(1)的时间复杂度内实现对指定节点进行插入（前插或后插）或者删除数据的操作，而顺序表进行数据元素的插入删除时所需的时间复杂度为O(n)。

//1.定义一个单链表数据类型；2.初始化单链表
//3.利用尾插法或者头插法建立一个单链表 +输出单链表中的data
//4.按值查找；5.按位查找 +求单链表的长度
//6.按位序插入；7.指定头节点之前的插入；8.指定头节点之后的插入
//9.按位序删除；10.对指定头节点进行删除
//重点在于指定节点的删除和插入，这是区分于顺序表的最大的不同的地方，对指定节点进行删除或者插入其时间复杂度仅为O(1)
#include<iostream>
using namespace std;
#include<stdio.h>
//1.定义一个单链表数据类型；2.初始化单链表
typedef struct Lnode
{
    int data;
    struct Lnode* next;
}Lnode, *Linkedlist;

bool Initialize(Linkedlist &Lx)  //int &b = a
{
    Lx = (struct Lnode*)malloc(sizeof(Lnode));
    if (Lx == NULL)
    {
        return false;
    }
    if (Lx != NULL)
    {
        Lx ->next == NULL;
    }
    return true;
}
//3.利用头插法建立一个单链表
Linkedlist Headinsert(Linkedlist &Lx)
{
    int x ;
    cout <<"请输入要插入的一个整数（输入-10086结束插入）："<<" ";
    cin >> x;
    while (x != -10086)
    {
        struct Lnode* S = (struct Lnode* )malloc(sizeof(Lnode));
        S ->data = x;
        S ->next = Lx->next;
        Lx->next = S;
        cout <<"请输入要插入的一个整数（输入-10086结束插入）："<<" ";
        cin >> x;
    }
    return Lx;
}
//3.使用尾插法建立一个单链表
Linkedlist Tailinsert(Linkedlist &Lx)
{
    int x;
    Lx = (Lnode* )malloc(sizeof(Lnode));
    Lnode* r = Lx;
    cout <<"请输入要插入的一个整数（输入-99结束插入）："<<" ";
    cin >> x;
    while (x != -99)
    {
        Lnode* s = (Lnode* )malloc(sizeof(Lnode));
        s->data = x;
        r->next = s;
        r = s;
        cout <<"请输入要插入的一个整数（输入-99结束插入）："<<" ";
        cin >> x;
    }
    r->next = NULL;
    return Lx;
}

//4.输出单链表中的data,并输出单链表的长度
void coutdata(Linkedlist& Lx, int &lenlx)
{
    cout <<"单链表中的数据依次为："<<" ";
    struct Lnode* p = Lx;
    // int len = 0;
    while (p->next != NULL)
    {
        cout << p->next->data <<" ";
        lenlx ++;
        p = p->next;
    }
    cout << endl;
    //cout << "单链表包含的数字个数为："<< lenlx << endl;
}
//4.按位查找；5.按值查找
bool Getelement(Linkedlist Lx, int i, int lenx)
{
    if (i > lenx||i <= 0)
    {
        return false;
    }
    
    struct Lnode* p = Lx;
    int j = 0;
    while (p!= NULL && j<i)
    {
        p = p->next;
        j++;
    }
    cout<<"输入的位序正确，查找到的数字为："<<p->data<<endl;
    return true;
};
//按值查找，并返回值所对应的位序
int Locatelement(Linkedlist Lx, int ex)
{
    struct Lnode* p = Lx;
    int j = 0;
    while (p != NULL && p->data != ex)
    {
        p = p->next;
        j++;
    }
    return j;
}
//6.按位序插入 时间复杂度O(n)
bool Insertelementi(Linkedlist& Lx, int ix, int ex)
{
    if (ix < 1)
    {
        return false;
    }
    int j = 0;
    Lnode* p = Lx;
    while (j< ix - 1 && p != NULL)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
    {
        return false;
    }
    Lnode* s = (Lnode* )malloc(sizeof(Lnode));
    s->data = ex;
    s->next = p->next;
    p->next = s;
    return true;
}
//9.按位序删除 时间复杂度O(n)
bool Deletelementi(Linkedlist& Lx, int ix, int& ex)
{
    if (ix < 1)
    {
        return false;
    }
    int j = 0;
    Lnode* p = Lx;
    while (j < ix-1 && p != NULL)
    {
        p = p->next;
        j++;
    }
    if (p == NULL)
    {
        return false;
    }
    Lnode* q = p->next;
    ex = q->data;
    p->next = q->next;
    free(q);
    return true;
}
//10.对指定头节点进行删除
bool Deletespecnode(Linkedlist Lx, Lnode* p, int& ex)
{
    if (p == NULL)
    {
        return false;
    }
    ex = p->data;
    Lnode* q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
    return true;
}
//7.指定节点的扦插操作
bool Insertbeforespecinode(Linkedlist& Lx, Lnode* p, int ex)
{
    if (p == NULL)
    {
        return false;
    }
    Lnode* s = (Lnode* )malloc(sizeof(Lnode));
    s->next = p->next;
    p->next = s;
    s->data = p->data;
    p->data = ex;
    return true;
}

int main()
{
    Linkedlist L;
    // if (Initialize(L))
    // {
    //     cout <<"内存分配成功，单链表初始化完毕"<<endl;
    // }
    // else{cout <<"内存分配失败，单链表初始化失败"<<endl;}
    //Headinsert(L);
    Tailinsert(L);
    int lenout = 0;
    coutdata(L, lenout);
    cout << "单链表包含的数字个数为："<< lenout << endl;
    // cout <<"请输入需要查找的位序"<<" ";
    // int x;
    // cin >> x;
    // if (Getelement(L, x, lenout))
    // {
    //     cout<<"查找完毕！"<<endl;
    // }
    // else{cout <<"进行查找的位序不合法"<<endl;}
    // int xin; int xvalue;
    // cout <<"请输入需要插入的位序："<<" ";
    // cin >> xin; 
    // cout <<"请输入需要插入的值："<<" ";
    // cin >> xvalue;
    // Insertelementi(L, xin, xvalue);
    // int lenout2 = 0;
    // coutdata(L, lenout2);
    // cout << "单链表包含的数字个数为："<< lenout2 << endl;

    // int y = -1; int z = -1;
    // cout <<"请输入需要删除的位序："<<" ";
    // cin >> y;
    // if (Deletelementi(L, y, z))
    // {
    //     cout << "所删除的值为："<< z <<endl;
    // }
    // else{cout<<"所输入的位序不合法"<<endl;}
    // int lenout3 = 0;
    // coutdata(L, lenout3);
    // cout << "单链表包含的数字个数为："<< lenout3 << endl;
    //10.对指定头节点进行删除 代码不完美，重点在于思想的实现
    // Lnode* p0 = L; int exx = -1;
    //删除第几位节点打几个next
    // p0 = p0->next->next->next;
    // if (Deletespecnode(L, p0, exx))
    // {
    //     cout <<"删除出来的值为：" <<exx <<endl;
    // }
    // else{cout <<"该节点不合法！" <<endl;}
    // int lenout4 = 0;
    // coutdata(L, lenout4);
    // cout << "单链表包含的数字个数为："<< lenout4 << endl;
    //插入到第几位节点前打几个next
    Lnode* p0 = L;
    p0 = p0->next->next->next->next->next;
    int exxx = 99999;
    if (Insertbeforespecinode(L, p0, exxx))
    {
        int lenout5 = 0;
        coutdata(L, lenout5);
        cout << "单链表包含的数字个数为："<< lenout5 << endl;
    }
    else{cout <<"插入的节点不合法"<<endl;}

    cout <<"请输入需要查找的值："<<" ";
    int x;
    cin >> x;
    cout << "该值所对应的位序为:" <<Locatelement(L, x) <<endl;

    system("pause");
    return 0;
}