【数据结构】线性表——链表

最新推荐文章于 2023-01-14 18:52:42 发布
最新推荐文章于 2023-01-14 18:52:42 发布
阅读量155 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 单链表 双链表 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43466788/article/details/117234946
版权

文章目录

知识框架

在这里插入图片描述

单链表

#include <iostream>
using namespace std;
/**
 * 1.单链表的定义
 */
 typedef struct LNode{
     int data;
     struct LNode *next;
 }LNode,*LinkedList;

 /**
  * 2.单链表的两种实现方式：不带头结点和带头结点
  */

 //2.1不带头结点

 //初始化一个空的单链表
 bool InitList2(LinkedList &L){
     L = NULL; // 空表，暂时没有任何结点：防止脏读数据
     return true;
 }
 //判断单链表是否为空
 bool Empty2(LinkedList L){
     return L==NULL;
 }

 //2.2带头结点

//初始化一个空的单链表
 bool InitList(LinkedList &L){
     L = (LNode *) malloc(sizeof (LNode));//分配一个头结点
     if (L==NULL){ //内存不足，分配失败
         return false;
     }
     L->next = NULL; //头结点暂时没有结点
     return true;
 }

//判断单链表是否为空
bool Empty(LinkedList L){
    return L->next == NULL;
 }

 /**
  * 3.单链表的插入
  */

 //【指定结点的后插操作】代码重构：插入操作大多都包括 在p结点后插入元素e，，可以单独封装成一个函数
 bool InsertNextNode(LNode *p,int e){
     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     if (s == NULL){ // 分配内存失败
         return false;
     }
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;
 }
 //【指定结点的前插操作】
 bool InsertPriorNode(LNode *p,int e){
     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     if (s == NULL){
         return false;
     }
     s->next = p->next;
     p->next = s;
     s->data = p->data;
     p->data = e;
     return true;
 }

 //3.1按位序插入（带头结点）：在第i个位置插入元素e
 bool ListInsert(LinkedList &L,int i,int e){
     if (i < 1){
         return false;
     }
     LNode *p = L; //指针p指向当前扫描到的结点
     int j = 0; //当前p指向的是第几个结点
     //循环找到第i-1个结点
     while (p != NULL && j < i-1){
         p = p->next;
         j++;
     }
/*     //i值不合法
     if (p==NULL){
         return false;
     }
     //插入操作
     LNode *s = (LNode *) malloc(sizeof (LNode));
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;*/
     return InsertNextNode(p,e);
 }

 //3.2按位序插入（不带头结点）
 bool ListInsert2(LinkedList &L,int i,int e){
     if ( i < 1){
         return false;
     }

     //两种情况：第一种插入到第一个结点，第二种插入到大于1的结点（找i-1结点，再插入）
     //1. 插入到第一个结点
     if (i == 1){
         LNode *s = (LNode *) malloc(sizeof (LNode));
         s->data = e;
         s->next = L;
         L = s;
         return true;
     }
     //2. 插入到大于1的结点（找i-1结点，再插入）
     LNode *p = L;
     int j = 1;
     while (p != NULL && j < i-1){
         p = p->next;
         j++;
     }
/*     if (p == NULL){
         return false;
     }
     LNode *s = (LNode *) malloc(sizeof (LNode));
     s->data = e;
     s->next = p->next;
     p->next = s;
     return true;*/
     return InsertNextNode(p,e);
 }

/**
 * 4.单链表的删除
 */

//4.1 按位序删除（带头结点）
bool ListDelete(LinkedList &L,int i,int &e){
    if (i < 1){
        return false;
    }
    //找到第i-1结点
     LNode *p = L;
    int j = 0;
    while (p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if (p == NULL){ //i值不合法
        return false;
    }
    if (p->next == NULL){//第i-1个结点后没有结点
        return false;
    }
    //删除第i个结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

//4.2 按位序删除（不带头结点）
bool ListDelete2(LinkedList &L,int i,int &e){
    if (i < 1){
        return false;
    }
    if (i == 1){
        LNode *p = L;
        L = p->next;
        free(p);
    }
    //找第i-1个结点
    LNode *p = L;
    int j = 1;
    while (p != NULL && j < i-1){
        p = p->next;
        j++;
    }
    if (p == NULL){
        return false;
    }
    if (p->next == NULL){
        return false;
    }
    //删除第i个结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
}

//4.3删除指定结点p【p不能为最后一个结点】
bool DeleteNode(LNode *p){
    if (p == NULL){
        return false;
    }
    LNode *q = p->next;
    p->data = q->data;
    p->next = q->next;
    free(q);
}

/**
 * 5.查找
 * 按位查找  按值查找  求单链表的
 */

//5.1按位查找【带头结点】
LNode * GetElem(LinkedList L,int i){
    if (i < 1){
        return NULL;
    }
    LNode *p = L;
    int j = 0;
    while (p != NULL && j < i){
        p = p->next;
        j++;
    }
    return p;
}

//5.2按值查找
LNode * LocateElem(LinkedList L,int e){
    LNode *p = L->next;
    while (p != NULL && p->data != e){
        p = p->next;
    }
    return p;
}

//5.3求表的长度
int Length(LinkedList L){
    LNode *p = L;
    int j = 0;
    while (p->next != NULL){ //注意点是p->next
        p = p->next;
        j++;
    }
    return j;
}

/**
 * 6.创建：尾插法和头插法
 */

//6.1尾插法
LinkedList ListTailInsert(LinkedList &L){
    int x; //要插入的数据元素
    L = (LNode *) malloc(sizeof (LNode)); //创建头结点
    //定义一个指针：指向最后一个元素
    LNode  *r = L;
    cin>>x; //输入要插入的数据值
    LNode *s;//要插入的结点
    while (x != 9999){ //x=9999结束
        s = (LNode *) malloc(sizeof (LNode));
        s->data = x;
        r->next = s;
        r = s;//再次指向最后一个元素
        cin>>x;
    }
    r->next = NULL; //尾结点指针置空
    return L;
}

//6.2头插法
LinkedList ListHeadInsert(LinkedList &L){
    int x;//要插入的数据元素
    L = (LNode *) malloc(sizeof (LNode));
    //定义一个指针指向头结点
    LNode *p = L;
    p->next = NULL;
    //要插入的结点
    LNode *s;
    cin>>x;
    while (x != 9999){
        s = (LNode *) malloc(sizeof (LNode));
        s->data = x;
        s->next = p->next;
        p->next = s;
        cin>>x;
    }
    return L;
}

//【单链表逆置】
LinkedList Reverse(LinkedList &L){
    //指向头结点
    LNode *p = L;
    //记录一下第一个结点
    LNode *first = L->next;
    //指向要插入的元素:从第二个元素开始
    LNode *q = L->next->next;
    //要插入的结点
    LNode *s;
    while (q != NULL){
        s = q;
        q = q->next;
        s->next = p->next;
        p->next = s;
    }
    //最后一个结点，及最先的第一个结点指向NULL
    first->next = NULL;
    return L;
}

/**
 * 输出链表全部元素
 */
 void ListPrint(LinkedList L){
     LNode *p = L->next;
    while (p != NULL){
        cout << p->data<<"   ";
        p = p->next;
    }
    cout<<endl;
 }


int main() {
    //头插法创建
    LinkedList L;
    ListHeadInsert(L);
    ListPrint(L);
    //逆置
    Reverse(L);
    ListPrint(L);
    //表长
    int length = Length(L);
    cout<<"Length: "<<length<<endl;
    //插入
    ListInsert(L,2,10);
    ListPrint(L);
    //删除
    int e = 0;
    ListDelete(L,3,e);
    ListPrint(L);
    return 0;
}

双链表

#include <iostream>
using namespace std;
/**
 * 1. 双链表的定义
 */

//1.1定义
typedef struct DNode{
    int data;
    struct DNode *prior,*next;
}DNode,*DLinkList;

//1.2初始化（带头结点）
bool InitDoubleList(DLinkList &L){
    L = (DNode *) malloc(sizeof (DNode)); //分配一个头结点
    if (L == NULL){
        return false;
    }
    L->prior = NULL; //头结点的前一个结点为NULL
    L->next = NULL; //下一个结点暂时为NULL
    return true;
}

//1.3 链表判空
bool IsEmpty(DLinkList L){
    return L->next == NULL;
}

/**
 * 2. 双链表的插入
 */

//2.1 在p结点之后插入s结点
bool InsertNextDNode(DNode *p,DNode *s){
    if (p == NULL || s == NULL){
        return false;
    }
    s->next = p->next;
    //p->next->prior = s; 这里注意p可能是最后一个结点，即p->next = NULL;
    if (p->next != NULL){
        p->next->prior = s;
    }
    s->prior = p;
    p->next = s;
    return true;
}

/**
 * 3. 双链表的删除
 */

//3.1 删除p结点的后继结点
bool DeleteNextDNode(DNode *p){
    if (p == NULL){
        return false;
    }
    //要删除的结点
    DNode *q = p->next;
    if (q == NULL){
        return false;
    }
    p->next = q->next;
    if (q->next != NULL){
        q->next->prior = p;
    }
    free(q);
    return true;
}

//3.2 销毁链表
void DestroyList(DLinkList &L){
    if (L == NULL){
        return;
    }
    while (L->next != NULL){
        DeleteNextDNode(L);
    }
    free(L);
    L = NULL; //指向NULL
}

/**
 * 4. 双链表的遍历
 */

//4.1 p结点的后向遍历
void TraverseBack(DNode *p){

    while (p != NULL){
        cout << p->data <<"  ";
        p = p->next;
    }

}

//4.2 p结点的前向遍历
void TraversePrior(DNode *p){

    while (p->prior != NULL){ //跳过头结点
        cout << p->data <<"  ";
        p = p->prior;
    }

}

int main() {

    //初始化
    DLinkList L;
    InitDoubleList(L);
    //插入数据
    DNode *s;
    for (int i = 1; i <= 5; ++i) {
        s = (DNode *) malloc(sizeof (DNode));
        s->data = i;
        InsertNextDNode(L,s);
    }
    //遍历
    TraverseBack(L->next);
    //销毁
    DestroyList(L);
    return 0;
}

循环链表

#include <iostream>
using namespace std;

/**
 * 1.循环链表的定义：循环单链表和循环双链表
 */

//1.1 循环单链表
typedef struct LNode {
    int data;
    struct LNode *next;
}LNode, *LinkList;

//初始化一个循环单链表
bool InitList(LinkList &L){
    L = (LNode *) malloc(sizeof (LNode));
    if (L == NULL){
        return false;
    }
    L->next = L;
    return true;
}

//判断循环单链表是否为空
bool IsEmpty(LinkList L){
    return L->next == L;
}

//判断结点p是否为循环单链表的尾结点
bool IsTail(LinkList L,LNode *p){
    return p->next == L;
}


//1.2循环双链表
typedef struct DNOde{
    int data;
    struct DNOde *prior,*next;
}DNOde,*LinkedList;

//初始化一个循环单链表
bool InitDLinkList(LinkedList &L){
    L = (DNOde *) malloc(sizeof (DNOde));
    if (L == NULL){
        return false;
    }
    L->next = L;
    L->prior = L;
    return true;
}
//判断循环双链表是否为空
bool Empty(LinkedList L){
    return L->next == L;
}

//判断结点p是否为循环单链表的尾结点
bool Tail(LinkedList L,DNOde *p){
    return p->next == L;
}

int main() {

    return 0;
}

静态链表

#include <iostream>
using namespace std;


/**
 * 1. 静态链表
 */
#define MaxSize 10   //静态链表的最大长度
typedef struct {
    int data;
    int next; //下一个元素的数组下标
}SLinkList[MaxSize];


int main() {

    return 0;
}
高 朗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】线性表之链表
xboll2020的博客
11-29 525
线性表之链表
数据结构线性表——顺序表、链表
qq_64105689的博客
05-14 639
1.线性表 线性表(linear list)是有n个相同特性的元素组成的有限序列，在逻辑上是线性结构，也就是连续的一条直线；但是在物理结构上，不一定是连续的。 常见的线性表有： 顺序表、链表、栈、队列、字符串.... 2.顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的数据结构，一般采用数组存储，在数组上完成增删查改。 顺序表一般分为： 1.静态的顺序表：使用定长数组存储元素。 define N 6 typedef int SeqListDataType; t.
数据结构线性表——链表概念学习
qq_65134001的博客
01-14 80
数据结构线性表的链表基本概念
初阶数据结构——线性表——链表——不带头单向链表
dtxew love c++
10-20 2852
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 知识回顾 在前一章中我们已经介绍了顺序表，相信大家对顺序表的实现已经有所了解了吧！ 但是，这种数据结构，难免会有以下的缺陷 我们在中间位置插入或删除数据的话，可能需要挪动后面的所有数据，时间复杂度较高==(O(n))== 我们的空间是按照2倍的常数开辟的，可能会造成空间的浪费，比
线性表——链表
weixin_46640900的博客
06-30 2549
顺序表和链表都是线性表的一种。但链表与顺序表不同的是，他的物理上与逻辑上的机构并不一致。 顺序表的话，逻辑相邻，物理上也是相邻的。所以对于一整块连续的物理地址，当我们进行插入和删除操作的时候就会需要大量的移动元素。 而链表不需要使用地址连续的存储单元，即不需要满足物理与逻辑一致，通过"链"建立数据之间的逻辑关系，当进行插入或删除操作的时候，只需要修改指针即可。线性表的链式存储为单链表，通过任意一组存储单元来存储数据。链表通过许多节点构成，节点除了放自身的数据还有存放下一个节点的地址来保证链表的逻辑关系。而链
线性表——链表PPT学习教案.pptx
10-01
线性表是一种基础的数据结构，通常用于组织和处理一系列有序数据。在计算机科学中，线性表有两种主要的存储方式：顺序存储和链式存储。本篇PPT着重讲解了链式存储结构，特别是链表的概念和应用。 链式存储结构克服...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构实验——线性表子系统
07-31
线性表是数据结构中最基础且重要的概念之一，它是由n(n≥0)个相同类型元素组成的有限序列。在这个实验中，我们主要关注线性表的链式存储结构，特别是字符型的单链表。实验的目标是理解线性表的特点，掌握顺序存储和...
c语言数据结构线性表创建删除插入
06-30
本主题聚焦于C语言中的数据结构——线性表，这是数据结构的基础概念之一，适用于初学者学习。线性表是一种逻辑上一维、元素之间具有线性关系的数据结构。下面将详细阐述线性表的创建、删除和插入操作。 1. **线性表...
数据结构——线性表的实现.zip
09-18
本资料包“数据结构——线性表的实现.zip”着重介绍了线性表的两种常见实现方式：链表和数组。 1. 链表实现： 链表是一种物理存储单元非连续、非顺序的存储结构，它通过节点间的指针链接来表示元素之间的逻辑关系...
【数据结构】查找与排序
高朗的博客
08-21 4264
文章目录考点顺序查找 考点 顺序、折半、分块查找：会求平均查找长度（注意不考B、B+树） 【重点】 散列表/哈希表：构造方法、求平均查找长度 八大排序的特点、时间、空间复杂度、稳定性：插入、快排、归并、堆排序是重点，除基数排序外都要能写出算法。 顺序查找 ...
【数据结构】线性表——顺序表
高朗的博客
05-20 679
文章目录知识框架基本操作代码 知识框架 基本操作代码 #include <iostream> using namespace std; /** * 1.顺序表的定义 * 两种方式：静态分配和动态分配 */ //1.1静态分配 #define MAXSIZE 50 //定义线性表的最大长度 typedef struct { int data[MAXSIZE];//ElemType data[MaxSize] 顺序表的元素 int length; //顺序表的当前长
【数据结构】图（重点）
高朗的博客
10-07 539
文章目录考点分析基本概念完全图dfs算法bfs算法应用 考点分析 有向图和无向图的存储,连通图与连通分量等基本概念。 完全图的边数、握手定理。 【重点】dfs、bfs的算法与应用。 最短路径、最小生成树、拓扑排序（都要能写代码)、关键路径（会找）等算法(超级重点，需结合OJ)。 基本概念 完全图 dfs算法 bfs算法 应用 ...
【数据结构】串（String）
高朗的博客
06-12 507
文章目录知识架构相关代码 知识架构 相关代码 #include <iostream> using namespace std; /** * 1. 串定义 */ //1. 静态数组 #define MAXLEN 255 typedef struct { char ch[MAXLEN]; int length; }SString; // 2. 动态 typedef struct { char *ch; int length; }HString; //
【数据结构】树
高朗的博客
07-14 404
文章目录知识架构相关代码 知识架构 相关代码 #include <iostream> using namespace std; /** * 1. 二叉树的存储结构 */ //1.1 顺序存储 #define MaxSize 100 struct TreeNode { int value[MaxSize]; bool isEmpty; }; //1.2 链式存储 typedef struct BiTNode{ int data; struct Bi
【数据结构】特殊矩阵的压缩存储
高朗的博客
06-05 175
文章目录知识框架对称矩阵三角矩阵三对角矩阵稀疏矩阵 知识框架 对称矩阵 三角矩阵 三对角矩阵 稀疏矩阵
【数据结构】线性表
高朗的博客
05-20 167
文章目录知识框架文章汇总 知识框架 文章汇总 【数据结构】线性表——顺序表 【数据结构】线性表——链式表达
【数据结构】栈
高朗的博客
05-31 166
文章目录知识框架基本操作代码 知识框架 基本操作代码 #include <iostream> using namespace std; /** * 1. 顺序栈 */ //1. 定义 #define MaxSize 10 typedef struct { int data[MaxSize]; //存放栈中元素 int top; //栈顶指针 }SqStack; //2. 初始化：栈顶指针指向-1 void InitStack(SqStack &S){
【数据结构】队列
高朗的博客
05-31 164
文章目录知识框架一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 知识框架 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np imp
高级线性表——静态链表
最新发布
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现思路是在数组中分配一段连续的空间，将链表中的各个结点存储在这个空间中，每个结点占用一个数组元素。数组中的第一个元素不存储结点数据，而是用来记录链表中第一个未被使用的结点的下标，通常称为头结点。静态链表的最后一个结点指向一个特殊的标记，通常为 -1，表示链表的结尾。 静态链表的实现可以解决链表的动态分配问题，因为它不需要像链表一样频繁地申请和释放内存。但是，静态链表的缺点是空间浪费，因为它需要预先分配一定的空间，如果链表中结点的数量超过了预分配的空间，就需要重新申请更大的空间。 静态链表支持链表基本操作，如插入、删除、查找等，具体实现可以参考链表的相关算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值