线性表（顺序存储，链式存储）（带头结点的链表，不带头结点的链表）

已于 2023-03-19 16:01:31 修改
阅读量265 收藏 2
点赞数
分类专栏： 中国MOOC浙大数据结构（代码） # 链表 数据结构 文章标签： 链表 数据结构
于 2022-07-15 11:07:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51825761/article/details/125800079
版权
本文介绍了线性表的基本操作，包括初始化、查找、插入和删除，并分别给出了顺序存储和链式存储两种实现方式。顺序存储使用数组实现，链式存储分为不带头结点和带头结点的链表实现。每个实现都包含详细的代码示例，展示了如何在指定位置插入和删除元素，以及查找指定元素和获取线性表的长度。
摘要由CSDN通过智能技术生成

 
    线性表的基本操作：
    List MakeEmpty(): 初始化一个新的空线性表；
    ElementType FindKth(List L,int i): 给定指定的位序，返回L中相应的元素ai;
    Position Find(List L,ElementType X) ：已知X，返回线性表L中与X相同的第一个元素
        的位置，若不存在则返回错误信息；
    bool Insert(List L,ElementType X,int i):在L的指定位序i前插入一个元素X，成功则返回true，
        否则返回false；
    bool Delect(List L,int i):从L中删除指定位序i的元素，成功则返回true，否则返回false；
    bool Length(List L):返回线性表L的长度；
 

/**
    1)线性表的顺序存储实现：
*/

/**
    线性表的基本操作：
    List MakeEmpty(): 初始化一个新的空线性表；
    ElementType FindKth(List L,int i): 给定指定的位序，返回L中相应的元素ai;
    Position Find(List L,ElementType X) ：已知X，返回线性表L中与X相同的第一个元素
        的位置，若不存在则返回错误信息；
    bool Insert(List L,ElementType X,int i):在L的指定位序i前插入一个元素X，成功则返回true，
        否则返回false；
    bool Delect(List L,int i):从L中删除指定位序i的元素，成功则返回true，否则返回false；
    bool Length(List L):返回线性表L的长度；
*/

/**
    1)线性表的顺序存储实现：
*/

/**
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define error -1
const int MAXSIZE = 100;
typedef int ElementType;
typedef int Position;
typedef struct LNode * PtrToLNode;
//  这里的位置就是数组的整型下标，从0开始，前面提到的位序是指第几个，从1开始
struct LNode
{
    ElementType Data[MAXSIZE];
    Position Last;
};
typedef PtrToLNode List;

List MakeEmpty();
ElementType FindKth(List L,int i);
Position Find(List L,ElementType X);
bool Insert(List L,ElementType X,int i);
bool Delect(List L,int i);
int Length(List L);
int main()
{
    List L=MakeEmpty();
    for(int i=1;i<15;++i)
        Insert(L,i,i);
    cout << "Insert:\n";
    for(int i=0;i<=L->Last;++i)
        cout << L->Data[i] << ' ';
    cout << endl;
    int K=20;
    if(FindKth(L,K)!=error)
    {
    printf("\n第%d号位找到了：\n",K);
    cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("\n该线性表不存在第%d号位的元素\n",K);
    printf("该线性表的元素个数为%d个\n",Length(L));
    for(int i=5;i<10;++i)
        Delect(L,i);
    cout << "Insert:\n";
    for(int i=0;i<=L->Last;++i)
        cout << L->Data[i] << ' ';

    K=5;
    if(FindKth(L,K)!=error)
    {
        printf("\n第%d号位找到了：\n",K);
        cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("该线性表不存在第%d的元素\n",K);

    printf("该线性表的元素个数为%d个\n",Length(L));
    return 0;
}

List MakeEmpty()
{
    List L;
    L=(List) malloc(sizeof(LNode));
    L->Last=-1;
    return L;
}
ElementType FindKth(List L,int i)
{
    if(i<1||i>L->Last)
    {
        printf("不存在第%d号位的元素\n",i);
        return error;
    }
    else
        return L->Data[i-1];
}

Position Find(List L,ElementType X)
{
    Position i=0;
    while(i<L->Last&&L->Data[i]!=X)
        ++i;
    if(i>=L->Last)
        return error;
    else
        return i;
}

bool Insert(List L,ElementType X,int i)
{
    if(L->Last==MAXSIZE-1)
    {
        printf("表满\n");
        return false;
    }

    if(i<1||i>L->Last+2)
    {
        printf("位序不合法\n");
        return false;
    }

    for(Position j=L->Last;j>=i-1;--j)
        L->Data[j+1]=L->Data[j];
    L->Data[i-1]=X;
    ++L->Last;
    return true;
}
bool Delect(List L,int i)
{
    if(L->Last<0)
    {
        printf("表空\n");
        return false;
    }
    if(i<1||i>L->Last+1)
    {
        printf("位序%d不存在元素\n",i);
        return false;
    }
    for(Position j=i;j<=L->Last;++j)
        L->Data[j-1]=L->Data[j];
    --L->Last;
    return true;
}

int Length(List L)
{
    return L->Last+1;
}
*/

 2)线性表的链式存储实现

    不带头结点的链表创建，插入，删除

/**
    2)线性表的链式存储实现

    不带头结点的链表创建，插入，删除
*/


#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define error NULL
const int MAXSIZE = 100;
typedef int ElementType;
const ElementType inf=1e9;
typedef struct LNode * PtrToLNode;
//  这里的位置就是数组的整型下标，从0开始，前面提到的位序是指第几个，从1开始
struct LNode
{
    ElementType data;
    PtrToLNode next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

List MakeEmpty();
ElementType FindKth(List L,int i);
Position Find(List L,ElementType X);
List Insert(List L,ElementType X,int i);
List Delect(List L,int i);
int Length(List L);

int main()
{
    List L=MakeEmpty();
    for(auto p=L;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    for(int i=1;i<15;++i)
    {
        auto tem=Insert(L,i,i);
        if(tem!=error)
            L=tem;
    }
    cout << "insert:\n";
    for(auto p=L;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));

    int K=20;
    if(FindKth(L,K)!=inf)
    {
        printf("\n第%d号位找到了：\n",K);
        cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("\n该线性表不存在第%d号位的元素\n",K);

    K=5;
    if(FindKth(L,K)!=inf)
    {
        printf("\n第%d号位找到了：\n",K);
        cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("该线性表不存在第%d的元素\n",K);

    printf("该线性表的元素个数为%d个\n",Length(L));

    for(int i=5;i<10;++i)
    {
        auto tem=Delect(L,i);
        if(tem!=error)
            L=tem;
    }
    cout << "delect:\n";
    for(auto p=L;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));

    auto tem=Delect(L,1);
    if(tem!=error)
        L=tem;
    cout << "delect first node:\n";
    for(auto p=L;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));

    return 0;
}

//不带头结点的链表创建：
List MakeEmpty()
{
    List L;
    L=(List) malloc(sizeof(LNode));
    L=NULL;
    return L;
}

ElementType FindKth(List L,int i)
{
    Position p;
    int cnt=1;
    p=L;
    while(p&&cnt<i)
    {
        p=p->next;
        ++cnt;
    }
    if(p&&cnt==i)
        return p->data;
    else
        return inf;
}

Position Find(List L,ElementType X)
{
    Position p=L;
    while(p&&p->data!=X)
        p=p->next;
    if(!p)
        return error;
    else
        return p;
}

List Insert(List L,ElementType X,int i)
{
    Position pre,tem;
    tem=(Position) malloc(sizeof (LNode));
    tem->data=X;
    if(i==1)
    {
        tem->next=L;
        return tem;
    }
    else
    {
        int cnt=1;
        pre=L;
        while(pre&&cnt<i-1)
        {
            pre=pre->next;
            ++cnt;
        }

        if(pre==NULL||cnt!=i-1)
        {
            printf("参入位置参数错误\n");
            free(tem);
            return error;
        }
        else
        {
            tem->next=pre->next;
            pre->next=tem;
            return L;
        }
    }
}

List Delect(List L,int i)
{
    Position pre=L,tem;
    if(i==1)
    {
        pre=L;
        tem=pre->next;
        free(pre);
        return tem;
    }
    else
    {
        int cnt=1;
        while(pre&&cnt<i-1)
        {
            pre=pre->next;
            ++cnt;
        }

        if(pre==NULL||cnt!=i-1)
        {
            printf("参入位置参数错误\n");
            free(tem);
            return error;
        }
        else
        {
            tem=pre->next;
            pre->next=tem->next;
            free(tem);
            return L;
        }
    }
}

int Length(List L)
{
    Position p=L;
    int len=0;
    while(p)
    {
        p=p->next;
        ++len;
    }
    return len;
}

3)线性表的链式存储实现

    带头结点的链表创建，插入，删除

/**
    3)线性表的链式存储实现

    带头结点的链表创建，插入，删除
*/
/**
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

#define error NULL
const int MAXSIZE = 100;
typedef int ElementType;
const ElementType inf=1e9;
typedef struct LNode * PtrToLNode;
//  这里的位置就是数组的整型下标，从0开始，前面提到的位序是指第几个，从1开始
struct LNode
{
    ElementType data;
    PtrToLNode next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

List MakeEmpty();
ElementType FindKth(List L,int i);
Position Find(List L,ElementType X);
bool Insert(List L,ElementType X,int i);
bool Delect(List L,int i);
int Length(List L);

int main()
{
    List L=MakeEmpty();
    for(auto p=L->next;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    for(int i=1;i<15;++i)
        Insert(L,i,i);
    cout << "insert:\n";
    for(auto p=L->next;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));

    int K=20;
    if(FindKth(L,K)!=inf)
    {
        printf("\n第%d号位找到了：\n",K);
        cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("\n该线性表不存在第%d号位的元素\n",K);

    K=5;
    if(FindKth(L,K)!=inf)
    {
        printf("\n第%d号位找到了：\n",K);
        cout << "此元素为 " << FindKth(L,K) << endl;
    }
    else
        printf("该线性表不存在第%d的元素\n",K);

    printf("该线性表的元素个数为%d个\n",Length(L));

    for(int i=5;i<10;++i)
        Delect(L,i);
    cout << "delect:\n";
    for(auto p=L->next;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));

    Delect(L,1);
    cout << "delect first node:\n";
    for(auto p=L->next;p;p=p->next)
        cout << p->data << ' ' ;
    cout << endl;
    printf("该线性表的元素个数为%d个\n",Length(L));
}

 //带头结点的链表创建：
List MakeEmpty()
{
    List L;
    L=(List) malloc(sizeof(LNode));
    L->next=NULL;
    return L;
}

ElementType FindKth(List L,int i)
{
    Position p;
    int cnt=1;
    p=L->next;
    while(p&&cnt<i)
    {
        p=p->next;
        ++cnt;
    }
    if(p&&cnt==i)
        return p->data;
    else
        return inf;
}

Position Find(List L,ElementType X)
{
    Position p=L->next;
    while(p&&p->data!=X)
        p=p->next;
    if(!p)
        return error;
    else
        return p;
}

bool Insert(List L,ElementType X,int i)
{
    Position pre,tem;
    int cnt=1;
    pre=L;
    while(pre&&cnt<i)
    {
        pre=pre->next;
        ++cnt;
    }

    if(pre==NULL||cnt!=i)
    {
        printf("插入位置参数错误\n");
        return false;
    }
    else
    {
        tem=(Position) malloc(sizeof (LNode));
        tem->data=X;
        tem->next=pre->next;
        pre->next=tem;
        return true;
    }
}

bool Delect(List L,int i)
{
    Position pre=L,tem;
    int cnt=1;
    while(pre&&cnt<i)
    {
        pre=pre->next;
        ++cnt;
    }

    if(pre==NULL||cnt!=i||pre->next==NULL)
    {
        printf("参入位置参数错误\n");
        return false;
    }
    else
    {
        tem=pre->next;
        pre->next=tem->next;
        free(tem);
        return true;
    }
}

int Length(List L)
{
    Position p=L->next;
    int len=0;
    while(p)
    {
        p=p->next;
        ++len;
    }
    return len;
}
*/

疯疯癫癫才自由
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式存储(单项链表)的设计与实现
05-06
链式存储相比于顺序存储，最大的优势在于它不需预先分配连续的内存空间，因此在插入和删除操作时更加灵活，无需移动大量元素。单项链表是链式存储的一种简单形式，每个节点包含数据域和一个指向下一个节点的指针域。...
2. 线性表-链式存储-链表1
08-03
在实际应用中，线性表可以采用两种不同的存储方式：顺序存储和链式存储。本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是一种动态数据结构，它的特点是元素（也称为节点）在内存中不是连续存放的，而是...
数据结构与算法（C语言） | 线性表（顺序存储、链式存储）
Shannon
04-17 7204
   线性表是最常用最简单的线性结构      线性结构具有以下基本特征:    线性结构是一个数据元素的有序（次序）集(处理元素有限)。若该集合非空，则 1)必存在唯一的一个“第一元素”； 2)必存在唯一的一个“最后元素”； 3)除第一元素之外，其余每个元素均有唯一的前驱； 4)除最后元素之外，其余每个元素均有唯一的后继。   抽象数据类型（ADT）格式： ADT 抽象数据类...
线性表之链表（链式存储）
m0_48566364的博客
03-05 532
本文章是在考研复习过程中通过观看网络上的讲解视频之后进行的归纳总结，以便日后的复习，同时也想分享给大家，如有问题和不足，还请多多指教！ 线性表之链表（链式存储） 顺序表与单链表比较 ~ 顺序表 单链表 结点 只存放数据元素 除存放数据元素，还存放指向下一结点指针 优点 可随机存取，存储密度高 不要求大片连续空间，改变容量方便 缺点 要求大片连续空间，改变容量不方便 不可随机存取，要耗费一定空间存放指针 目录线性表之链表（链式存储）单链表带头结点的单链表不带头结点 单链表 结构体
线性表的链式存储结构
weixin_60475929的博客
11-18 919
线性表的链式存储结构 元素本身+下一个元素的指针 单链表的定义 每个结点只包含一个指针域，叫做单链表 链表中第一个结点存储位置叫做头指针，最后一个结点指针为空（NULL） 用c语言可用结构指针来描述单链表 typedef struct Node { ElemType data; //数据域 struct Node* Next;//指针域 }Node； typedef struct Node*LinkList; typedef单链表使用方法...
1.2_线性表之链式存储
JJL的博客
10-05 220
目录 1. 初始化 2. 增删 (改)查操作 2.1 按位序插入 2.2 指定结点的后插和前插 2.3 按位序删除 2.4 删除指定结点 1. 初始化 L 是一个指向 LNode 型的指针,更进一步来理解就是声明一个指向单链表第一个结点的指针。 2. 增删 (改)查操作 2.1 按位序插入 2.2 指定结点的后插和前插 2.3 按位序删除 ...
数据结构(线性表链式存储)的几个基本操作
weixin_50731537的博客
12-05 452
取结点个数 取结点个数时,cnt从0开始 //求单链表的表长 //从首元结点开始,依次计数所有结点 int ListLength_L(Linklist L) { int cnt = 0; LNode* p; p = L->next; while (p != NULL) { cnt++; p = p->next; } return cnt; } //取值,取单链表中第i个元素的内容 取第i个元素的内容时,cnt从1开始 因为p的初值时L->next,如果p不为NULL时
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
带头节点的链式存储线性表
07-16
带头节点的线性表的链式存储实现，实现了带头节点链表的创建，不同功能的插入操作，按位置插入，头插入尾插入。也有按数据，按位置删除链表的功能。压缩包中有可执行文件，也有makefile，在linux下直接make即可生成...
c语言数据结构实验：掌握线性表的链式存储结构 熟练掌握循环链表的存储特征和建立方法，掌握线性表的链式存储结构 下面是源码的txt
10-13
2、设计一算法，逆置带头结点的动态链表L。要求利用原表的结点空间，并要求用尽可能少的时间完成。 假设在长度大于1的单循环链表中，既无头结点也无头指针。s 为指向某个结点的指针，试编写算法删除结点*s 的直接...
线性链表（线性表的单链表存储结构）
yezeen的博客
07-31 1241
一、单链表存储结构 //线性表的单链表存储结构 typedef struct LNode { int data; struct LNode* next; }LNODE, *LINKLIST; *代码段中的结构体定义也可以表示为 struct LNode { int data; struct LNode* next; }; typedef struct LNode LNODE; typedef struct LNode* LINKLIST; 二、基本操作&其他操作的函数定义 1.
数据结构--线性表的链式存储
XUN__MLF的博客
02-24 2204
链式存储相关术语： 数据域：存储元素数值数据 指针域：存储直接后继结点的存储位置 结点：数据元素的存储映像。又1数据域和指针域两部分组成 链表：n个结点由指针链组成一个链表 单链表，双链表，循环链表 结点只有一个指针域的链表，称为单链表或线性链表 结点有两个指针域的链表，称为双链表 首尾相接的链表称为循环链表 头指针、头结点、和首元结点 头指针：是指向链表中第一个结点的指针 首元结点：是指链表中
带头结点单链表 (详解)
热门推荐
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-02 1万+
结构体后的*List是一个指向结构体的指针类型，我们通过它来定义该类型的指针。如：List p ; 则这个p就是指向LinkedList结构体的一个指针，也就是单链表的头指针。（所以说头指针是必然存在的，但单链表不一定有头结点，注意区分头指针和头结点）
数据结构 线性表的顺序存储和链式存储，以及基本操作、单链表例题
qq_53334934的博客
10-29 979
线性表
简单的算法（1）--从尾到头打印链表
小牛呼噜噜的博客
11-08 207
目录 1、java实现 1.1、递归 1.1.1、测试（完整源码） 1.2、利用栈来实现 1.2.1、测试 2、C语言 2.1、先将链表反转，再从头输出（改变链表的结构） 2.2、利用栈的“先进后出”特性   1、java实现 链表的定义： public class ListNode { int val; ListNode next = ...
3-2-链表 带头结点的链式表操作集 (20 分)
weixin_54641695的博客
07-17 1075
本题要求实现带头结点的链式表操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; struct LNode { ElementType Data;
6-6 带头结点的链式表操作集
purpleai的博客
05-04 359
本题要求实现带头结点的链式表操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P ); 其中List结构定义如下： typedef struct L...
4-3 求链式表的表长
Ken
06-20 5804
本题要求实现一个函数，求链式表的表长。函数接口定义：int Length( List L ); 其中List结构定义如下：typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode List; L是给定单链表，函数Len
C++中将数组线性表转换为链表
Jeff_Winger的博客
10-22 3568
//将数组线性表转换为链表 template void chain::fromList(arrayList&theList) { int i = 0; T temp= theList.get(0); firstNode = new chainNode(temp, firstNode); do { chainNode*p = firstNode; int k = 0; whil
线性表的链式实现：不带头结点与带头结点的单链表
"本文主要介绍了表的几种链式实现方式，包括不带头结点的单链表、带头结点的单链表、循环单链表、双链表以及双向循环链表。这些实现方法是数据结构中表的常用存储结构，它们在不同的场景下有各自的优势和适用性。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值