数据结构单链表头插法，尾插法，按值查询，按位置插入，，，代码实战

Miraitowa338

已于 2023-07-08 18:06:27 修改

阅读量115

点赞数

文章标签：数据结构链表

于 2023-07-08 17:27:59 首次发布

本文链接：https://blog.csdn.net/qq_56799156/article/details/131614464

版权

代码可以直接复制运行，单链表结点的建立采用while循环，函数的命名格式与王道书上保持一致

单链表定义

typedef int ElemType;
typedef struct LNode {

ElemType data;

struct LNode* next;

}LNode,*LinkList;

这段代码定义了一个带头结点的单链表。其中，ElemType为单链表中数据元素的类型，LNode是单链表的结点结构体，包含一个存储数据元素的成员data和一个指向下一个节点的指针next。最后还定义了两个类型别名，LNode*表示指向LNode型结点的指针类型，LinkList表示指向单链表第一个结点（头结点）的指针类型。这样定义的好处是使代码更加简洁易懂，并使得单链表的各个函数接口更加清晰明了。

struct LNode* next;

这行代码定义了一个指向结构体LNode的指针成员next。其中，struct关键字是为了指明LNode是一个结构体类型，*表示它是一个指针类型，next是指针成员的名称。这个指针成员通常用来指向单链表中下一个节点的位置，以实现链表的链接作用。在单链表的操作中，我们需要很频繁地使用这个指针，例如在插入节点时需要修改前一个节点的指针域，以及新节点的指针域；在删除节点时需要修改前一个节点的指针域，使其指向被删除的节点的下一个节点。因此，这个指针成员是单链表结构体中非常重要的一个成员。

`#define` 是C语言中的预处理指令，用于定义常量或宏。

`#define OK 1` 定义了一个常量 `OK`，其值为1。`OK` 可以在代码中作为一个标识符使用，代表成功或正确的状态。

`#define ERROR 0` 定义了一个常量 `ERROR`，其值为0。`ERROR` 同样可以在代码中作为一个标识符使用，代表错误或失败的状态。

这样定义常量或宏的好处是可以提高代码的可读性和维护性。在代码中使用 `OK` 和 `ERROR` 来表示状态，可以让代码更加清晰和易于理解。此外，定义这样的常量还可以方便地在整个代码中进行统一修改，而不需要逐个查找和修改具体的数值。

Malloc函数：L=（强制转换类型）malloc（sizeof（结构体的大小））

申请的是指向已分配内存块的起始地址。是一个指针类型

在带有头结点的单链表L中第i个位置之前的插入元素e

void ListInsert_L(LinkList L, int i, int e)
{
    LinkList p, s;
    int j;
    int rrr;
    rrr = LenthList_L(L);
    if (i < (rrr + 1) && i>0)
    {
        p = L->next; j = 1;
        while (p && j < i - 1)
        {
            p = p->next; ++j;
        }
        if (!p || j > i - 1) return ERROR;
        s = (LinkList)malloc(sizeof(Lnode));
        s->data = e; s->next = p->next;
        p->next = s;
        return OK;
    }
    else {
        printf("插入位置有误\n\n");
    }
}

该函数用于在链表中的第 i 个位置上插入一个新节点，新节点的数据值为 e。

LinkList 是指向链表头节点的指针。

int i 表示要插入位置的序号。
int e 表示要插入的节点数据。
rrr = LenthList_L(L) 可能是计算链表长度的函数调用，它将链表 L 的长度赋值给变量 rrr。
首先，通过判断插入位置 i 是否合法（大于0且不超过链表长度），如果合法则执行插入操作，如果不合法则输出错误提示信息。
在合法位置插入前，通过遍历链表找到第 i-1 个节点 p。
如果链表为空或者找到的位置不合法，则返回错误。
否则，创建一个新节点 s，保存数据 e，并将节点 s 插入 p 的后面。

最后，新节点插入成功。

在带有头结点的单链表L中，删除第i个元素，并由e返回其值

//在带有头结点的单链表L中，删除第i个元素，并由e返回其值
Status ListDelete_L(LinkList L, int i, int* e)
{
    LinkList p, q;
    int j;
    int eee = LenthList_L(L);
    if (i < eee + 1 && i>0)
    {
        p = L->next; j = 1;
        while (p->next && j < i - 1)
        {
            p = p->next; ++j;
        }
        if (!(p->next) || j > i - 1)return ERROR;
        q = p->next; p->next = q->next;
        *e = q->data;
        free(q);
        return OK;
    }
    else {
        printf("输入位置有错\n\n");
    }
}

p为前驱，q为需要删除的，先用遍历的方式找到p，然后指针next找到q

该函数用于删除链表中第 i 个位置的节点，并将删除节点的数据值保存到指针 e 指向的变量中。

LinkList 是指向链表头节点的指针。

int i 表示要删除的节点位置。
int* e 是指向保存删除节点数据的变量的指针。
eee = LenthList_L(L) 可能是计算链表长度的函数调用，它将链表 L 的长度赋值给变量 eee。
首先，通过判断删除位置 i 是否合法（大于0且不超过链表长度），如果合法则执行删除操作，如果不合法则输出错误提示信息。
在合法位置删除前，通过遍历链表找到第 i-1 个节点 p。
如果链表为空或者找到的位置不合法，则返回错误。
否则，将第 i 个节点 q 的指针保存起来，然后更新链表，将节点 p->next 指向 q 的下一个节点，从而删除节点 q。
将删除节点的数据值保存到指针 e 指向的变量中。
最后，释放删除节点的内存，返回执行成功状态。

完整代码

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;//函数，可以自定义返回值的函数类型

//单链表的存储结构
typedef struct LNode
{
    ElemType data;
    struct LNode* next;
} LNode, * LinkList;/*取别名，LNode单链表结构体别名，LinkList、
是结构体指针类型别名*/

//初始化
Status InitList(LinkList& L)
{
    L = new LNode;
    L->next = NULL;
    return OK;
}
//销毁
Status DestroyList(LinkList& L)
{
    LinkList p;
    while (L)
    {
        p = L;
        L = L->next;
        delete p;
    }
    return OK;
}
//清空
Status ClearList(LinkList L)
{// 将L重置为空表
    LinkList p, q;
    p = L->next;   //p指向第一个结点
    while (p)       //没到表尾
    {
        q = p->next; delete p; p = q;
    }
    L->next = NULL;   //头结点指针域为空
    return OK;
}
//求长度
int  ListLength(LinkList L)
{  //返回L中数据元素个数
    LinkList p = L->next; //p指向第一个结点
    int count = 0;
    while (p) {//遍历单链表,统计结点数，p的值不为0就是真，执行循环
        ++count;
        p = p->next;
    }
    return count;
}
//判断是否为空
bool ListEmpty(LinkList L)
{//若L为空表，则返回true，否则返回false
    if (L->next == NULL)
        return true;
    else
        return false;
}
//取值
Status GetElem(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 ERROR;
    e = p->data;
    return OK;
}
//按值查找
LNode* LocateElem(LinkList L, ElemType e)
{
    LinkList p = L->next;
    while (p && p->data != e)
        p=p->next;
    return p;
}
//插入
Status ListInsert(LinkList& L, int i, ElemType e)
{
    LinkList p = L;
    int j = 0;
    while (p && (j < i - 1))
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i - 1) return ERROR;
    LinkList s = new LNode;
    s->data = e;
    s->next = p->next;//找到前驱，将前驱的next赋过去
    p->next = s;
    return OK;
}
//删除
Status ListDelete(LinkList& L, int i)
{
    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 q = p->next;
    p->next = q->next;
    delete q;
    return OK;
}
//前插法创建单链表
void Creat_Head(LinkList &L)  //头插法
{
    LNode* p;
    int i = 1;
    printf("以头插法建立单链表\n");
    printf("当输入 0 时结束\n");
    while (1)
    {
        printf("输入第%d个元素:\n", i);
        i++;
        p = (LNode*)malloc(sizeof(LNode));
        scanf_s("%d", &p->data);
        if (p->data == 0)  break;
        else {
            p->next = L->next;
            L->next = p;
        }
    }
}

//后插法创建单链表
void Creat_Tail(LinkList & L)  //尾插法
{
    LNode* p, * q;
    q = L;
    int i = 1;
    printf("以尾插法建立单链表\n");
    printf("当输入 0 时结束\n");
    while (1)
    {
        printf("输入第%d个元素:\n", i);
        i++;
        p = (LNode*)malloc(sizeof(LNode));
        scanf_s("%d", &p->data);
        if (p->data == 0)  break;
        else {
            p->next = q->next;//就不需要再NULL
            q->next = p;
            q = p;
        }
    }
}
//查找哪个元素的前驱
Status ListPrior(LinkList L, ElemType cur_e, ElemType* pre_e)
{
    LinkList q = L->next;//第一个结点
    if (!q)//若链表为空
        return ERROR;
    LinkList p = q->next;//第二个结点
    while (p)
    {
        if (p->data == cur_e)
        {
            *pre_e = q->data;
            return OK;
        }
        else
        {
            q = p;
            p = p->next;
        }
    }
    return ERROR;
}
//查找哪个元素的后继
Status ListNext(LinkList L, ElemType cur_e, ElemType* next_e)
{
    LinkList p = L->next;
    while (p)
    {
        if (p->data == cur_e && p->next)
        {
            *next_e = p->next->data;
            return OK;
        }
        else
            p = p->next;
    }
    return ERROR;
}
//显示线性表
void DisplayList(LinkList L)
{
    LinkList p = L->next;
    while (p)
    {
        cout << p->data << "  ";
        p = p->next;
    }
    cout << endl;
    return;
}
void show_help()
{
    cout << "******* Data Structure ******" << endl;
    cout << "1----清空线性表" << endl;
    cout << "2----判断线性表是否为空" << endl;
    cout << "3----求线性表长度" << endl;
    cout << "4----获取线性表指定位置元素" << endl; 
    cout << "5----头插法新建链表" << endl;
    cout << "6----尾插法新建链表" << endl;
    cout << "7----在线性表指定位置插入元素" << endl;
    cout << "8----删除线性表指定位置元素" << endl;
    cout << "9----显示线性表" << endl;
   
    cout << "     退出，输入0" << endl;

}
int main()
{
    char operate_code;
    show_help();
    LinkList L;
    InitList(L);
    ElemType e;
    int i;
    while (1)
    {
        cout << "请输入操作代码:";
        cin >> operate_code;
        if (operate_code == '1')
        {
            cout << "The list has been cleared." << endl;
            ClearList(L);//调用操作函数

        }
        else if (operate_code == '2')
        {
            if (ListEmpty(L))
                cout << "The list is empty." << endl;
            else
                cout << "The list is not empty." << endl;

        }
        else if (operate_code == '3')
        {
            cout << "The length of list is:" << ListLength(L) << endl;

        }
        else if (operate_code == '4')
        {
            cout << "请输入指定的位置：" << endl;
            cin >> i;
            if (GetElem(L, i, e) == 1) cout << "这个位置的数据是：" << e << endl;
            else cout << "error" << endl;
        }
        else if (operate_code == '5')
        {
            Creat_Head(L);
            printf("建立完成！\n");
        }
        else if (operate_code == '6')
        {
            Creat_Tail(L);
            printf("建立完成！\n");
        }
        
        else if (operate_code == '7')
        {
            cout << "请输入插入元素及其位置：" << endl;
            cin >> e >> i;
            if (ListInsert(L, i, e) == ERROR) cout << "您的输入不合法" << endl;

        }
        else if (operate_code == '8')
        {
            cout << "请输入你想要删除哪个位置的元素：" << endl;
            cin >> i;
            if (ListDelete(L, i) == ERROR)  cout << "error" << endl;

        }
        else if (operate_code == '9')
        {
            cout << "The contents of the list are:" << endl;
            DisplayList(L);

        }
        
        
        else if (operate_code == '0')
        {
        
            break;
        }
        else
        {
            cout << "\n操作码错误！！！" << endl;
            show_help();
        }
        }
        //调用销毁线性表函数，如Destroy_List(L);
        DestroyList(L);
        return 0;
        }