数据结构与算法——（2.5.2）链表的补充算法

清园暖歌

已于 2022-03-22 21:23:12 修改

阅读量1.8k

点赞数

分类专栏：数据结构与算法文章标签：数据结构算法链表

于 2022-03-21 22:59:15 首次发布

本文链接：https://blog.csdn.net/qq_47941078/article/details/123643146

版权

数据结构与算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文详细介绍了单链表的各种基本操作，包括判断链表是否为空、销毁链表、清空链表、求链表长度、按值查找元素、插入新节点、删除节点等。同时，提供了相应的C++实现，并分析了时间复杂度，对于理解和操作链表数据结构具有指导意义。

摘要由CSDN通过智能技术生成

int ListLength_L(LinkList &L){    // 返回L中数据元素个数
    LinkList &p;
    p = L -> next;    // p指向第一个结点
    i = 0;
    while(p)          // 遍历单链表，统计结点数
    {
        i++;
        p = p -> next;// 此处最后一个结点虽然指针域为为空，但是数值域是有值的，即为有地址的
                      // 而p则指向地址，所以最后一个结点是加上了的
    }
    return i;         // 返回元素个数
}

回顾

5. 取值——取单链表中第i个元素的内容

顺序表：L -> elem[i - 1];

算法思路：顺着首元结点计数去找，知道计数计到第i个，所以称顺序存取。

Sattus GetElem_L(LinkList L, int i, ElemType &e){    
// 获取线性表L中的某个数据元素的内容，通过变量e返回
    p = L -> next;
    j = 1;               // 初始化
    while(p && j < i)    // 向后扫描，直到p指向第i个元素或p为空
    {
        p = -> next;
        ++j;
    }
    if(!p || j>i)
        return ERROR;    // 第i个元素不存在
    e = p -> data;       // 取第i个元素
    return OK;
} // GetElem_L

6.1 查找——按值查找（1）

按值查找——根据指定数据获取该数据所在的位置（地址）

算法思想：从首元结点开始遍历所有结点，并判断数值域是否与要查找的相同，直至查找完毕或没有结束，若有返回地址。

Lnode *LocateElem_L(LinkList L, Elemtype e){
// 在线性表L中查找值为e的数据元素
// 找到，则返回L中值为e的数据元素的地址，查找失败返回NULL
    p = L -> next;
    while(p && p -> data != e)
        p = p -> next;
    return p;    // 返回地址
}

6.2 查找——按值查找（2）

按值查找——根据指定数据获取该数据位置序号

算法思想：从首元结点开始遍历所有结点，并判断数值域是否与要查找的相同，直至查找完毕或没有结束，若有返回位置序号。

// 在线性表L中查找值为e的数据元素的位置序号
int LocateElem_L(LinkList L, Elemtype e){
// 返回L中值为e的数据元素的位置序号，查找失败返回0
    p = L -> next;
    j = 1;
    while(p && p -> data != e)
    {
        p = p -> next;
        j++;
    }
    if(p)
        return j;
    else
        return 0;
}

7. 插入——在第i个结点前插入值为e的新结点

算法思想：从首元结点开始先找第i-1个结点。

步骤①和步骤②不可直接互换。

// 在L中第i个元素之前插入数据元素e
Status ListInset_L(LinkList &L, int i, ElemType e){
    p = L;
    j = 0;
    while(p && j<i-1)
    {
        p = p -> next;
        ++j;    // 寻找第i-1个结点，p指向i-1结点
    }
    if(!p || j>i-1)
        return ERROR;    // i大于表长+1或者小于1，插入位置非法
    s = new LNode;
    s -> data = e;       // 生成新结点s，将结点s的数据域置为e
    s -> next = p -> next;
    p -> next = s;       // 将结点s插入L中
    return OK;
}    // ListInset_L

8. 删除——删除第i个结点

算法思想：从首元结点开始先找第i-1个结点，next域指向i+1的结点，原i+1地址由第i个结点指向，删除i结点。

// 将线性表L中第i个数据元素删除
Staus ListDelete_L(LinkList &L, int i, ElemType &e){
    p = L;
    J = 0;
    while(p -> next && j < i-1)
    {
        p = p -> next;
        ++j;
    }    // 寻找第i个结点，并令p指向其前驱
    if(!(p -> next) || j > i-1)
        return ERROR;        // 删除位置不合理
    q = p -> next;           // 临时保存被删除结点的地址以备释放
    p -> next = q -> next;   // 改变删除结点前驱结点的指针域
    e = q -> data;           // 保存删除结点的数据域
    delete q;                // 释放删除结点的空间
    return OK;
}    // ListDelete_L

9. 建立单链表：头插法（前插法）——元素插入在链表头部

算法思想：

Void CreateList_H(LinkList &L, int n){
    // 插入次数为n
    L = new LNode;
    L -> next = NULL;    // 先建立一个带头结点的单链表
    for(i=n; i>0; --i)
    {
        p = new LNode;    // 生成新结点 p = (LNode*)malloc(sizeof(LNode));
        cin >> p -> data;    // 输入元素值 scanf(&p -> data);
        p -> next = L -> next;    // 插入到表头
        L -> next = p;
    }
}    // CreateList_H

算法时间复杂度是：O(n)。

10. 建立单链表：尾插法（后插法）——元素插入在链表尾部

算法思想：

// 正位序输入n个元素的值，建立带表头结点的单链表L
void CreateList_R(LinkList &L, int n){
    L = new LNode;
    L -> next = NULL;
    r = L;    // 尾指针r指向头结点
    for(i=0; i<n; ++i)
    {
        p = new LNode;
        cin >> p -> data;    // 生成新结点，输入元素值    
        p -> next = NULL;
        r -> next = p;       // 插入到表尾
        r = p;               // r指向新的尾结点
    }
}    // CreateList_R

算法时间复杂度是：O(n)。