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

最新推荐文章于 2024-03-24 21:57:09 发布
最新推荐文章于 2024-03-24 21:57:09 发布
阅读量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
    评论
专栏目录
线性表——链表的创建
AnRuxaing的博客
08-25 762
头插法，尾插法，双链表，单链表
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构线性表——链表概念学习
qq_65134001的博客
01-14 80
数据结构线性表的链表基本概念
初阶数据结构——线性表——链表——不带头单向链表
dtxew love c++
10-20 2852
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 知识回顾 在前一章中我们已经介绍了顺序表，相信大家对顺序表的实现已经有所了解了吧！ 但是，这种数据结构，难免会有以下的缺陷 我们在中间位置插入或删除数据的话，可能需要挪动后面的所有数据，时间复杂度较高==(O(n))== 我们的空间是按照2倍的常数开辟的，可能会造成空间的浪费，比
线性表——链表
weixin_46640900的博客
06-30 2549
顺序表和链表都是线性表的一种。但链表与顺序表不同的是，他的物理上与逻辑上的机构并不一致。 顺序表的话，逻辑相邻，物理上也是相邻的。所以对于一整块连续的物理地址，当我们进行插入和删除操作的时候就会需要大量的移动元素。 而链表不需要使用地址连续的存储单元，即不需要满足物理与逻辑一致，通过"链"建立数据之间的逻辑关系，当进行插入或删除操作的时候，只需要修改指针即可。线性表的链式存储为单链表，通过任意一组存储单元来存储数据。链表通过许多节点构成，节点除了放自身的数据还有存放下一个节点的地址来保证链表的逻辑关系。而链
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构线性表——栈
2303_78442132的博客
11-13 1880
栈、数据结构、线性表
【数据结构】线性表——循环链表
最新发布
m0_62632116的博客
03-24 187
【数据结构】循环链表
初阶数据结构——线性表——链表——带头双向循环链表
dtxew love c++
10-28 2690
????????想快速入门数据结构，推荐订阅作者的初阶数据结构专栏！此专栏预计更新：顺序表，链表，栈，队列，二叉树，排序算法等等 ????????初阶数据结构我们通过c语言实现，所以此专栏也可以帮助大家巩固大家的c语言知识 ????????源代码已上传至我的码云 ????????博主的微信公众号关注啦，关注我每天学习一道题，点我关注 前言 其中在链表的实现中有很多种实现方法，主要取决于以下几个因素 单向还是双向？ 循环还是不循环？ 带头还是不带头 这几个特征两两组合，就可以看做一种链表的
数据结构 基本代码——线性表，链表实现 C语言
LloveN0128的博客
10-30 446
单链表功能的实现。
线性表——链表（双向链表）
m0_63756571的博客
09-06 462
本文介绍了常见数据结构链表中双向链表的介绍，并用Java对其进行了简单的实现，同时对其进行了时间复杂度的分析。
线性表——链表PPT学习教案.pptx
10-01
线性表是一种基础的数据结构，通常用于组织和处理一系列有序数据。在计算机科学中，线性表有两种主要的存储方式：顺序存储和链式存储。本篇PPT着重讲解了链式存储结构，特别是链表的概念和应用。 链式存储结构克服...
数据结构实验——线性表子系统
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; //
高级线性表——静态链表
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值