数据结构（2）线性表

最新推荐文章于 2023-04-07 00:13:26 发布
最新推荐文章于 2023-04-07 00:13:26 发布
阅读量205 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44113772/article/details/116192802
版权
本文详细介绍了线性表的概念，包括顺序表和链表两种主要的存储结构。顺序表利用数组实现，逻辑顺序与物理顺序一致，但插入删除操作可能涉及大量元素移动。链表则通过节点储存元素及其前后关系，便于插入和删除，但额外占用指针存储空间。文中列举了顺序表和链表（单链表、双链表、循环链表）的主要操作，如插入、删除、查找等，并提供了相应的算法实现。此外，还讨论了有序线性表的归并策略。
摘要由CSDN通过智能技术生成

一.线性表的基本概念

1.定义：具有相同特性的数据元素的有限序列。

2.逻辑特征：起始元素没有前驱元素，其他元素有且仅有一个前驱元素；终端元素没有后继元素，其他元素有且仅有一个后继元素。

3.存储结构：顺序储存，链式储存两种。

 3.1顺序表：把元素按照逻辑顺序依次储存到连续的存储空间。即逻辑顺序与物理顺序一致。

                     这样线性表第一个元素的储存位置就是指导储存空间的起始位置，第i+1个元素储存位置紧邻第i个元素的储存位置。

                     顺序表无需为元素的逻辑关系增加额外的存储空间，可以随机存取任一元素。

                     但是占用了整片连续的存储空间，插入和删除需要移动大量的元素，十分不便。

   3.1.1顺序表的算法：借助数组实现，可以是静态分配或者动态分配。

静态分配时数组大小和空间固定，一旦占满，再加入新的数据就会溢出。

#define MaxSize 50
typedef struct 
{
    ElemType data[MaxSize];//存放顺序表的元素
    int length;            //存放顺序表的长度
}SqList;                   //声明顺序表的类型

动态分配时数组大小和空间在程序执行过程中通过动态储存分配语句分配，一旦占满，就开辟更大的代替。

#define  InitSize 100
typedef struct 
{
    ElemType *data;//存放顺序表的元素
    int length，MaxSize;            //存放顺序表的长度和最大容量
}SqList;                   //动态分配顺序表的类型定义

                 初始化：时间复杂度O(1)

void InitList(SqList &L)
{
    L.length=0;
}

                求指定位置元素值:时间复杂度O(1)

void GetElem(SqList L,int i,ElemType &e)
{
    if(i<1||i>L.length)         
        return 0;
    e=L.data[i-1];
        return 1;
}

             求指定元素值:时间复杂度O(n)

int LocateElem(SqList L,ElemType e)
{
    int i;
    for(i=0;i<L.length;i++) 
        if(L.data[i]==e)
             return i+1;
        return 0; 
}

           插入元素：时间复杂度O(n)

int ListInsert(SqList &L,ElemType e,int i)
{
    int j;
    if(i<1||i>L.length+1)
        return 0;
    for(j=L.length;j>i;j--)
        L.data[j]=L.data[j-1];
    L.data[i-1]=e;
    L.length++;
    return 1;
}

      删除元素:时间复杂度O(n)

int ListDelete(SqList &L,int i,ElemType &e)
{
    int j;
    if(i<1||i>L.length)
        return 0;
    e=L.data[i-1];
    for(j=i;j<L.length;j++)
        L.data[j-1]=L.data[j];
    L.length--;
    return 1;  
}

     有序顺序表的归并:时间复杂度O(n+m)

void Merge(SqList L1,SqList L2,SqList &L3)
{
    int i=0,j=0,k=0;
    while(i<L1.length && j<L2.length)
    {
        if(L1.data[i]<L2.data[j])
        {
            L3.data[k]=L1.data[i];
            i++;k++;
        }
        else
        {
            L3.data[k]=L2.data[j];
            j++;k++;
        }
    }
    while(i<L1.length)
    {
            L3.data[k]=L1.data[i];
            i++;k++;
        }
     while(j<L2.length)
    {
            L3.data[k]=L2.data[j];
            j++;k++;
        }
    L3.length=k;
}

3.2链表：每个节点储存一个元素（数据域）以及元素的关系，即前驱节点包含后继节点的位置信息（指针域）。

                 如果某个节点的指针域不指向如何其他节点，那么值置空（NULL）。

                 因为带有指针域，所以使用了更多地存储空间，也无法随机存储，但是进行删除和插入操作时只需要修改相关节点的指针域，不需要移动节点。

   3.2.1单链表：除数据域外，只设置一个指针域，指向后继节点。解决了需要连续存储单元的缺点，但是浪费存储空间。是非随机存取结构。通常使用头指针标识单链表，设置头节点。使用头结点可以存放第一个数据元素的位置，所以第一个数据元素与其他位置的操作一致，空表与非空表的处理也一致。

节点类型使用LinkList表示，声明如下：

typedef struct LNode
{
    ElemType data;     //数据域
    struct LNode *next;//指向后继节点的指针
}LinkList;             //声明单链表节点类型

头插法建立单链表(倒序)：时间复杂度O(n)

void CreateListF(LinkList &L)
{
    LinkList *s;int i;
    L=(LinkList *)malloc(sizeof(LinkList));        //创建头节点
    L->next=NULL;                                  //头节点next域置NULL              
    for(i=0;i<n;i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));    //创建新节点
        s->data=i;
        s->next=L->next;                           //*s插入头节点之后
        L->next=s;
    }
}

 尾插法建立单链表(正序)：时间复杂度O(n)

void CreateListR(LinkList &L)
{
    LinkList *s,*r;int i;
    L=(LinkList *)malloc(sizeof(LinkList));        //创建头节点
    r=L;                                           //r始终指向尾节点，开始时指向头节点              
    for(i=0;i<n;i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));    //创建新节点
        s->data=i;
        r->next=s;                           //*s插入*r之后
        r=s;
    }
    r->next=NULL;
}

按元素值查找： 时间复杂度O(n)

void LocateElem(LinkList *L,ElemType e)
{
    LinkList *p=L->next;            //p指向第一个节点
    int n=1;
    while(p!=NULL && p->data!=e)
    {
        p=p->next;
        n++;
    }
    if(p==NULL) return 0;
    else return n;
}

按序号值查找： 时间复杂度O(n)

void GetElem(LinkList *L,ElemType e)
{
    int j=1;
    LinkList *p=L->next;            //p指向第一个节点
    if(e==0) return L;
    if(e<0) return NULL;
    while(p && j<e)
    {
        p=p->next;
        j++;
        
    }
     return p;
}

插入节点：即先查找插入节点的前一个节点位置，然后插入

p=GetElem(L,e-1);
s->next=p->next;
p->next=s;

删除节点：即先查找插入节点的前一个节点位置，然后删除

p=GetElem(L,e-1);
p->next=p->next->next;

有序单链表的归并

1.尾插法建立L3,时间复杂度O(n+m),空间复杂度O(n+m)

void Merge(LinkList *L1,LinkList *L2,LinkList &*L3)
{
    LinkList *p=L1->next,*q=L2->next,*r,*s; //pq分别遍历L1L2
    L3=(LinkList *)malloc(sizeof(LinkList));//创建L3的头节点
    r=L3;                                   //r指向L3的尾节点 
    while(p!=NULL && q!=NULL)
    {
        if(p->data[]<q->data[])
        {
            s=(LinkList *)malloc(sizeof(LinkList));//复制*p得到*s
            s->data[]=p->data[];
            p=p->next;
            r->next=s;                              //*s连接到L3末尾 
            r=s;
        }
        else
        {
            s=(LinkList *)malloc(sizeof(LinkList));//复制*q得到*s
            s->data[]=q->data[];
            q=q->next;
            r->next=s;                              //*s连接到L3末尾 
            r=s;
        }
    }
    if(q!=NULL) p=q;
    while(p!=NULL)
    {
            s=(LinkList *)malloc(sizeof(LinkList));//复制*p得到*s
            s->data[]=p->data[];
            p=p->next;
            r->next=s;                              //*s连接到L3末尾 
            r=s;
     }
      r->next=NULL;
}

2.破坏L1L2重组L3,时间复杂度O(n+m),空间复杂度O(1)

void Merge(LinkList *L1,LinkList *L2,LinkList &*L3)
{
    LinkList *p=L1->next,*q=L2->next,*r,; //pq分别遍历L1L2
    L3=L1;//L1的头节点做L3的头节点
    free（L2）;                                   //释放L2的头节点 
    r=L3;
    while(p!=NULL && q!=NULL)
    {
        if(p->data[]<q->data[])
        {
            r->next=p;                              //*p连接到L3末尾 
            r=s;
            p=p->next;
          }
        else
        {
            r->next=p;                              //*q连接到L3末尾 
            r=s;
            q=q->next;
        }
    }
    if(q!=NULL) p=q;
            r->next=p;                              //未遍历的表的其余节点连接到L3末尾 
}

   3.2.2双链表：设置两个指针域，分别指向前驱和后继节点。

节点类型描述：

typedef struct DNode{
    ElemType data;            //数据域             
    struct DNode *prior,*next;//前驱，后继指针
}DNode,*DLinklist;

   插入

//头插法
void CreateDListF(DLinkList *&L,ElemType a[],int n)
{
    DLinkList *s;
    int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));//创建头节点
    L->next=L->prior=NULL;//创建空双链表
    for(i=0;i<n;i++)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));//创建新的节点
        s->data=a[i];
        s->next=L->next;//将*s插在首节点前，头节点后
        if(L->next!=NULL)
            L->next->prior=s;
        L->next=s;
        s->prior=L;
    }
}
//尾插法
void CreateDListR(DLinkList *&L,ElemType a[],int n)
{
    DLinkList *s,*r;
    int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));//创建头节点
    r=L;//r始终指向终端节点，开始时指向头结点
    for(i=0;i<n;i++)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));//创建新的节点
        s->data=a[i];
        r->next=s;//将*S插入*r后
        s->prior=r;
        r=s;
    }
    r->next=NULL;
}

查找指定值的节点 

//尾插法
int Finfnode(DLinkList *L,ElemType x)
{
    LinkList *p=L->next;
    int i=1;
    while(p!=NULL&&p->data!=x)
    {
        i++;
        p->next;
    }
    if(p==NULL) return 0;
    else return i;
}

插入

int ListInsert(DLinkList *&L,ElemType e,int i)
{
    int j=0;
    DLinkList *p=L,*s;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));
        d->data=e;
        s->next=p->next;
        if(p->next!=NULL)
            p->next->prior=s;
        s->prior=p;
        p->next=s;
        return 1;
    }
}

删除

int ListDelete(DLinkList *&L,ElemType &e,int i)
{
    int j=0;
    DLinkList *p=L,*q;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
    {
        q=p->next;
        if(p==NULL) return 0;
        p->next=q->next;
        if(p->next!=NULL)
           q->next->prior=p; 
        free(q);
        return 1;
    }
}

    3.2.3循环链表：表中尾节点的指针域不是空，而是指向表头节点，整个链表形成环。

对于循环单链表判空条件不是头节点的指针是否为空，而是是否等于头指针。

//头插法
void CreatCListF(LinlList *&L,ElemType a[],int n)
{
     LinkList *s;int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=L;//设置为空
    for(i=0;i<n:i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=L->next;
        L->next=s;      
    }
}


//尾插法
void CreatCListR(LinlList *&L,ElemType a[],int n)
{
    LinkList *r,*s;int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;//尾指针指向终端节点
    for(i=0;i<n:i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;   
        r=s;   
    }
    r->next=L;
}


//查找值
int FinDList(LinlList *L,ElemType x)
{
    LinkList *p=L->next;
    int n=1;
    while(p!=L&&p->data!=x)
    {
        p=p->next;
        n++;
    }
    if(p==L) return 0;
    else return n;
}

//插入
q->next=p->next;
p->next=q;
//删除
p->next=p->next->next;

对于循环双链表判空条件是头结点的prior和next等于L。

//头插法
void CreatCDListF(LinlList *&L,ElemType a[],int n)
{
    DLinkList *s;int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    L->next=L->prior=L;//设置为空
    for(i=0;i<n:i++)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));
        s->data=a[i];
        s->next=L->next;
        if(L->next!=NULL)
            L->next->prior=s
        L->next=s;      
        s->prior=L;
    }
}


//尾插法
void CreatCDListR(LinlList *&L,ElemType a[],int n)
{
    LinkList *r,*s;int i;
    L=(DLinkList *)malloc(sizeof(DLinkList));
    r=L;//尾指针指向终端节点
    for(i=0;i<n:i++)
    {
        s=(DLinkList *)malloc(sizeof(DLinkList));
        s->data=a[i];
        r->next=s;  
        s->prior=r; 
        r=s;   
    }
    r->next=L;
    L->prior=r;
}

 

//查找值
int FinCDList(LinlList *L,ElemType x)
{
    DLinkList *p=L->next;
    int n=1;
    while(p!=L&&p->data!=x)
    {
        p=p->next;
        n++;
    }
    if(p==L) return 0;
    else return n;
}

//插入
q->next=p->next;
p->next->prior=q;
q->prior=p;
p->next=q;
//删除
q=p->next;
p->next=q->next;
q->next->prior=p;

 3.2.4静态链表：借用一维数组描述线性链表，数组的分量表示元素，游标代替指针。需要预先分配一块连续的内存空间。以next=1结束。

#define MaxSize 50
typedef struct{
    ElemType data;
    int next;
}SLinkList[MaxSize];

 

<千繁/>
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线性表的基本知识点+例题
misakisaigao的博客
12-04 1749
线性表的定义 线性表是一种最简单的线性结构，一个线性表是n个数据元素的有序序列。 同一线性表中的元素必定具有相同特性，就是要属于同一数据对象，相邻数据元素之间存在着序偶关系（序偶：一对有序的数） 在一个线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量元素的线性表又叫文件。 MOOC上是： 线性表：由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称表头，表结束位置称表尾 【线性结构是一个数据元素的有序集
每日微软面试题——day 5
热门推荐
花心龟 cabin
08-11 1万+
题：两个链表，一升一降。合并为一个升序链表。 分析：（假设升序的链表为链表1，降序的链表为链表2，p1，p2分别作为它们的迭代器，还有一个合并链表用于存放合并后的数据） 法一、最容易想到的且容易实现的就是使两个表都变成升序，然后就是经典的合并排序算法的步骤了，步骤是构建p1，
算法题回顾：双指针链表系列集锦
最新发布
Briwisdom的博客
04-07 637
如下示意图，首次相遇，slow走了k步， fast走了2k步，环的长度是k, 假设相遇节点离环的起点距离是n, 则从头节点到slow位置是k, 从头节点到环起点begin是k-n。判断环的起点：只需要在fast和slow相遇时候，将slow节点重新指向头节点，然后slow和fast指针开始同步前进，当再次相遇时候，即为环的起始节点。基本版本：遍历两遍链表，第一遍 知道链表的长度n,第二遍，倒数第k个节点，就是正数第n-k+1个节点，输出第n-k+1个节点。给一个链表数组，每个链表都是升序排列。
leecode-试水
40KO的博客
06-05 321
1.两数之和 描述：给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 暴力循环 没啥好说的，最容易想到的逻辑，时间复杂度O(n2) 双指针 排序后，利用双指针向中间逼近，知道找到目标值，时间复杂度O(nlogn) class Solution { public: vector<int> two...
[算法]【刷题笔记】链表专题
代码充实生活的博客
03-28 994
必备知识 链表是一种兼具递归和迭代性质的数据结构 一、合并两个有序链表（虚拟头结点） /** *Definitionforsingly-linkedlist. *publicclassListNode{ *intval; *ListNodenext; *ListNode(){} *ListNode(intval){this.val=val;} *ListNode(intval,Li...
数据结构2线性表
11-14
这是数据结构的第二章线性表，想看的可以看看。
数据结构之线性表.rar
04-07
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **...
北邮 数据结构实验 线性表
05-21
北邮数据结构实验线性表 本资源详细介绍了北邮数据结构第一次实验中的线性表实验报告，包括实验要求、存储结构、关键算法分析和测试main()函数等方面的内容。 在存储结构方面，本资源介绍了带头结点的单链表的存储...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
数据结构C++语言版 -- 线性表
catlv77的博客
02-27 542
大二学生的 C++数据结构有部分Openjudge提交的代码没有删除 邮箱：liu_772021@yeah.net 欢迎交流讨论~ 有用的话，点赞留言就可以表示感谢啦 #include <stdio.h> #include <iostream> #include <cstring> #include <cmath> using namespace std; typedef int ElemType; #define MAX_SIZE 100.
线性表的链式表示
qq_40369277的博客
07-06 90
线性表的链式表示
数据结构—单链表的操作与实现—c++代码（含全部代码）
Initial_Mind的博客
01-21 6867
单链表的操作与实现
求单链表的最大值与原地逆转_求單鏈表的最大值與原地逆轉
weixin_35554273的博客
01-13 100
數據結構鏈表一章已學習完畢，因此編了一個程序用以實現鏈式表的構建，插入，查找，求最大值，以及原地逆轉。除了求最大值與原地逆轉之外都是常規操作，不再贅述，着重分析最大值與逆轉的算法。一、最大值的求解：通過max函數實現，定義結構體指針p指向l的首元節點，max初值為p->data，通過if判斷是否有更大的數，將更大的數賦值給max，同時p指向下一個節點，由此求出最大的數。代碼如下：void m...
单链表的基本操作（详细）
qq_43346784的博客
07-06 8819
单链表的基本操作（详细）
第三章 线性表的链式存储结构（单链表超详细讲解）
qq_62822533的博客
12-17 1110
目录3.6.1 线性表链式存储结构定义3.6.2 单链表的存储结构3.6.3 单链表基本操作的实现（一）单链表的初始化（二）判断链表是否为空（三）销毁单链表（四）清空单链表（五）求单链表的表长（六）取单链表中的第i个元素的内容（七）按值查找——根据指定数据获取该数据所在的位置（地址）（八）按值查找--根据指定数据获取该数据位置序号（九）在L中第i个元素之前插入数据元素e（十）删除--删除第i个结点（十一）头插法（十二）尾插法3.6.3 全部代码定义：n个结点链结成一个链表，即为线性表（）的链式存储结构。
小菜一步一步学数据结构之(四)单链表
weixin_33736649的博客
01-16 123
上一篇博客学习了顺序表，最后也说明了顺序表属于静态存储，数据元素的个数不能自由的扩充。为了解决这个问题我们引入了链表 链表存储结构 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻，因此线性表的链式表示又称为非顺序映像或链式映像。 各个结点有两个域组成： * 数据域:存储元素数值数据 *...
【数据结构】双向链表定义和基本操作
Z_sea的博客
12-18 5883
双向链表： 双向链表的定义： typedef struct DuLNode{ LElemType data; struct DuLNode *next; struct DuLNode *pre; DuLNode ( LElemType Data=0,struct DuLNode *Pre=NULL,struct DuLNode *Next=NULL){ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

<千繁/>

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值