数据结构-线性表

最新推荐文章于 2024-11-15 16:34:20 发布
最新推荐文章于 2024-11-15 16:34:20 发布
阅读量78 收藏
点赞数 1
分类专栏： 数据结构小知识专栏 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiu_yue_ya/article/details/130608853
版权
本文介绍了线性表的概念，包括顺序存储结构和链式存储结构。顺序存储使用数组实现，优点是元素间存取速度快，但插入和删除效率低。链式存储利用指针链接元素，插入和删除操作高效，但需要额外的指针空间，且元素在内存中不连续。此外，文章还讨论了静态链表和双向链表等变体及其优缺点。
摘要由CSDN通过智能技术生成
        线性表是零个或多个数据元素的有限序列，首先线性表是一个序列，也就是说，元素之间是有顺序的，若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他买个元素都有且只有一个前驱和后继。

线性表的顺序存储结构  

        线性表的顺序存储结构是指用一段地址连续的存储单元依次存储 线性表的数据元素。示意图如下：

         我们经常使用的数组就是一类顺序存储的线性表，它是地址连续的一类存储单元，下面将使用程序设计一下这种顺序线性表。

#define MAXSIZE 20 //线性表最大元素个数
typedef int ElemType; //线性表元素类型
typedef struct
{
    ElemType data[MAXSIZE]; //线性表
    int length; //线性表中已有元素个数
}Sqlist; //线性表管理
       这样我们便完成了一个简单线性表的设计。
        data 就是我们的线性表，我们主要是对他进行一个增删改查操作。很多算法也是基于顺序线性表进行操作的，例如我们的排序算法，下面来了解下顺序线性表的操作。

获取元素操作 

/*
q:线性表指针
x:表示获取线性表第几个元素的值
m:保存获取的值
返回值为-1 失败，为 0 成功
*/
int GetValue(Sqlist *q,int x,ElemType *m)
{
    if(q == NULL || q->length == 0 || x >= q->length || x < 0)
        return -1;
    *m = q->data[x];
    return 0;
}

插入操作

/*
q:线性表指针
n:待插入的值
flag:插入方式标值：为 1 表示头插，为 2 表示表示正序插入，为 3 表示倒序插入，
为 4 表示尾插
返回值为-1 失败，为 0 成功
*/
int InsertionValue(Sqlist *q,ElemType n,int flag)
{
    if(q == NULL || q->length == MAXSIZE)
        return -1;
    if(flag == 1) //头插
    {
        for(int i = q->length;i > 0;i--)
        {
            q->data[i] = q->data[i-1];
        }
        q->data[0] = n;
        q->length++;
        return 0;
    }
    else if(flag == 2) //正序
    {
        int i;
        for(i = 0;i < q->length;i++) //找到插入位置
        {
            if(q->data[i] >= n)
                break;
        }
        for(int j = q->length;j > i;j--) //往后移
        {
            q->data[j] = q->data[j-1];
        }
        q->data[i] = n;
        q->length++;
        return 0;
    }
    else if(flag == 3) //倒序
    {
        int i;
        for(i = 0;i < q->length;i++) //找到插入位置
        {
            if(q->data[i] <= n)
                break;
        }
        for(int j = q->length;j > i;j--) //往后移
        {
            q->data[j] = q->data[j-1];
        }
        q->data[i] = n;
        q->length++;
        return 0;
    }
    else //尾插
    {
        q->data[q->length] = n;
        q->length++;
        return 0;
    }
}

删除指定值操作

/*
q:线性表指针
n:待删除的值
返回值为-1 失败，为 0 成功
*/
int DeleteValue(Sqlist *q,ElemType n)
{
    if(q == NULL || q->length == 0)
        return -1;
    for(int i = 0;i < q->length;i++)
    {
        if(q->data[i] == n)
        {
            for(int j = i;j < q->length;j++)
            {
                q->data[j] = q->data[j+1];
            }
            q->length--;
            i--;
        }
    }
    return 0;
}

清空操作 

void empty(Sqlist *q)
{
    q->length = 0;
}

线性表顺序存储的优缺点

优点：
        1.无须为表示表中元素之间的逻辑关系而增添额外内存空间，向链式存储会需要添加一个链表指针用来连接其他元素。
        2.可以快速的存取表中任意位置的元素，因为是地址连续，所以可以使用地址偏移去轻松找到其他元素。
缺点:
        1.插入和删除操作需要移动大量元素
        2.当线性表长度变化较大时，难以确定存储空间的容量
        3.造成存储空间的碎片

线性表的链式存储结构

        线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这就意味着这些数据元素元素可以存在内存未被占用的任意位置。

         为了表示每个数据元素 ai于其直接后继数据元素 ai+1之间的关系，对于 ai而言，其内部不仅存放了自己的数据消息之外，还有一个指针指向其直接后继的地址，所以一个链式线性表每一个节点都由两部分组成，数据域和指针域。

        设计一个链式线性表应该如下，对于节点设计要有数据域和指针域，另外，由于链式存储的地址不连续性，是没法在任意位置通过地址偏移去找到其他元素的，只能通过访问节点的指针域找到下一个节点，这样，就需要一个链表管理者结构来记录我们头节点和尾节点的位置，以方便我们对链表的访问，设计如下。

 

typedef struct Link //链表节点
{
    /*数据域*/
    char data[10];
    int num;
    /*指针域*/
    struct Link *next
}LinkNode;
typedef struct _Head //节点管理，方便找到头和尾
{
    LinkNode *first; //指向头节点
    LinkNode *tail; //指向尾节点
    int num; //节点个数
}Head

单链表的插入操作示例

/**
* 插入操作
* lk：链表管理
* x:待插入元素
* the：插入方式
*/
void insert_linkedist(Head *lk,int x,int the) //插入元素到链表
{
    if(lk == NULL)
    {
        return;
    }
    //创建节点
    Node *p = (Node*)malloc(sizeof(Node));
    p->date=x;
    p->next=NULL;
    if(the==1) //头插法
    {
        if(lk->num==0) //如果链表中没有元素
        {
            lk->first=p;
            lk->tail=p;
        }
        else
        {
            p->next=lk->first;
            lk->first=p;
        }
        (lk->num)++;
    }
    else if(the==2) //尾插法
    {
        if(lk->num==0) //如果链表中没有元素
        {
            lk->first=p;
            lk->tail=p;
        }
        else
        {
            lk->tail->next=p;
            lk->tail=p;
        }
        (lk->num)++;
    }
    else if(the==3) //升序排列
    {
        if(lk->num==0) //如果链表中没有元素
        {
            lk->first=p;
            lk->tail=p;
        }
        else
        {
            Node *q=lk->first; //用于遍历
            if(lk->first->date>=p->date) //插入元素比链表所有元素小
            {
                p->next=lk->first;
                lk->first=p;
            }
            else if(lk->tail->date<=p->date) //插入元素比链表所有元素大
            {
                lk->tail->next=p;
                lk->tail=p;
            }
            else
            {
                Node *t=q; //用于遍历，保证 p 插入位置在 t 和 q 之间
                while (q)
                {
                    if(q->date>=p->date)
                    {
                        q->next=p;
                        p->next=q;
                        break;
                    }
                    t=q;
                    q=q->next;
                }
            } 
        }
        (lk->num)++;
    }
    else //输入错误
    {
        return;
    }
}

 单链表的删除操作示例

/**
* lk:链表管理节点
* x：待删除的值
*/
void delete_all(Head *lk,TYPE x) //删除一个无序链表中指定的值
{
    if(lk==NULL || lk->num==0)
        return;
    Node *qk=lk->first; //指向要删除元素
    Node *qr=qk; //指向要删除元素前一个
    while (qk)
    {
        Node *t=qk;
        if(qk->date==x)
        {
            qk=qk->next;
            if(qr == t) //说明删除的首节点
            {
                qr->next == NULL;
                qr = qk;
            }
            else
                qr->next=qk;
            (lk->num)--;
            free(t);
            continue;
        }
        qr=qk;
        qk=qk->next;
    }
    if(lk->num == 0)
    {
        lk->first = NULL;
        lk->tail = NULL;
    }
}

 单链表的优缺点

从存储分配方式来看：
        顺序存储结构用一段连续的存储单元依次存储线性表数据元素。而单链表采用链式结构，用一组任意的存储单元存放线性表的元素
从时间性能来说：
        顺序存储的查找时间复杂度为 O(1),而单链表为 O(n),但是顺序存储的插入和删除时间复杂度为 O(n),而链式存储的时间复杂度为 O(1)
从空间性能来看：
        顺序存储结构需要分配存储空间，分大了，浪费，分小了易发生上溢。而链式存储不需要一开始分配空间，只要有需要就分配，元素个数也不受限制。

链表的几种形式

        上面我们讲述了线性表的链式存储结构以及设计方法和优缺点，对于数组来言，我们可以设计二维数组，指针数组，结构体数组等多种类型的数组，那么链表我们也可以设计成很多不同的样子，在学习数据结构，我们不应该花很多心思去学习每个结构的使用方法，更重要的是要去理解这种结构的一个思想，例如对于链式结构而言，它的思想就是使用指针域来指向下一元素位置，使两个逻辑上连续的空间物理上不一定连续。

静态链表

        我们在上面对链表进行学习我们找到，链表中每个节点具有数据域和指针域，每个节点的位置在内存中不连续，所以我们称这种链表为一个动态链表，而静态链表则是在内存上空间连续的一块数组空间，不过使用链表的思想将其演变为一个链表而已，我们称这种链表为静态链表。 其设计如下： 
#define NUM_MAX 1000
typedef int TYPE;
typedef struct LinkNode
{
    TYPE data; //数据域 保存节点数据
    int cur; //游标域 保存下一个元素的数组下标
}sLink;
int NodeNum = 0; //记录节点数量
sLink StaticLink[NUM_MAX];
        其中，NUM_MAX 表示静态链表的最大容量，静态链表分为数据域和游标域，游标中存储着此节点的下一个节点的下标，这样在对数据进行操作时，就不需要做到严格意义上的连续，例如，StaticLink[10].cur = 50.这样表示 StaticLink[10]的下一个元素不会是StaticLink[11]了，而是StaticLink[50]。
静态链表的初始化操作： 
void init()
{
    for(int i=0;i<NUM_MAX-1;i++)
        StaticLink[i].cur = i+1;
    StaticLink[NUM_MAX-1] = 0;
}
        一般静态链表的头元素和尾元素都不会用来存储数据，头元素的 cur 一般用来表示存储空位下标，例如一开始下标为 1 的数组元素要用来保存数据，则 StaticLink[0].cur保存的就是 1，而 StaticLink[NUM_MAX-1].cur 中保存的是存储数据首元素的下标，例如，如果这个静态链表中有很多元素，一开始没有首元素先初始化为 0，StaticLink[10]是作为逻辑上第一个元素，那么 StaticLink[NUM_MAX-1].cur 中保存的就是 10.
静态链表的插入操作： 
/**
* x:插入元素
* io：插入方法
* n:插入位置
*/
void Interposition(TYPE x,int io，int n)
{
    if(StaticLink[0].cur == NUM_MAX -1) //满
        return;
    if(io == 1) //尾插
    {
        if(StaticLink[NUM_MAX-1].cur == 0) //表示插入的是第一个元素
        {
            StaticLink[StaticLink[0].cur].data = x;
            StaticLink[StaticLink[0].cur].cur = 0; //最后一个元素游标保存 0
            StaticLink[NUM_MAX-1].cur == StaticLink[0].cur;
            StaticLink[0].cur = StaticLink[StaticLink[0].cur].cur;//保存下一个空位
        }
        else
        {
            int i = 1; //从第一个元素遍历，找到插入前的最后一个元素
            while(1)
            {
                if(StaticLink[i].cur == 0)
                {
                    StaticLink[i].cur = StaticLink[0].cur;
                    break;
                }
            }
            StaticLink[StaticLink[0].cur].data = x;
            StaticLink[StaticLink[0].cur].cur = 0; //最后一个元素游标保存 0
            StaticLink[0].cur = StaticLink[StaticLink[0].cur].cur;//保存下一个空位
        }
    }
    else if(io == 2) //头插
    {
        if(StaticLink[NUM_MAX-1].cur == 0) //表示第一个元素
        {
            StaticLink[StaticLink[0].cur].data = x;
            StaticLink[StaticLink[0].cur].cur = 0; //最后一个元素游标保存 0
            StaticLink[NUM_MAX-1].cur == StaticLink[0].cur;
            StaticLink[0].cur = StaticLink[StaticLink[0].cur].cur;//保存下一个空位
        }
        StaticLink[StaticLink[0].cur].data = x; 
        StaticLink[0].cur = StaticLink[StaticLink[0].cur].cur; //保存下一个空位
        StaticLink[StaticLink[0].cur].cur = StaticLink[NUM_MAX-1].cur; //下一个元素为原来的第一个元素
    }
    else //插入第 n 个元素之前的位置
    {
        int f = StaticLink[NUM_MAX-1].cur; //指向插入前的那个元素下标
        int q = f; //指向插入后的那个元素下标
        if( n<=1 || n>NodeNum)
            return;
        for(int i = 1; i<n;i++)
        {
            f = q;
            q = StaticLink[f].cur;
        }
        StaticLink[StaticLink[0].cur].data = x;
        StaticLink[StaticLink[0].cur].cur = q;
        StaticLink[f].cur = StaticLink[0].cur;
        StaticLink[0].cur = StaticLink[StaticLink[0].cur].cur; //保存下一个空位
    }
    NodeNum ++;
}

静态链表的删除操作：

/**
* x:待删除元素
* 
*/
void DeleteNode(TYPE x)
{
    if(LinkNode == 0) //无元素
        return;
    int f = StaticLink[NUM_MAX-1].cur; //指向删除前的那个元素下标
    int q = f; //指向删除后的那个元素下标
    for(int i = 0;i < LinkNode;i++)
    {
        if(StaticLink[q].data == x) //x 是要被删除的
        {
            if(q == StaticLink[NUM_MAX-1].cur) //如果是第一个元素
            {
                StaticLink[NUM_MAX-1].cur = StaticLink[q].cur;
            }
            else
            {
                StaticLink[f].cur = StaticLink[q].cur;
            }
            int t = StaticLink[0].cur;
            StaticLink[0].cur = f; //指向首空位
            StaticLink[q].cur = t; //保存下一个空位
            continue;
        }
        f = q;
        q = StaticLink[f].cur;
    }
}

静态链表优缺点分析:

优点：
        在插入和删除操作时，只需要修改游标，不需要移动元素，从而改进了在顺序存储结构中的插入和删除操作需要移动大量元素的缺点。
缺点：
        没有解决连续存储分配带来的表长难以预测的问题，失去了顺序存储的结构随机存取的特性。

循环链表

         循环链表就是将单链表中终端节点的指针由空指针改成指向头节点，就能使整个单链表形成一个环。这种头尾相接的单链表为单循环链表，简称循环链表

 双向链表

        双向链表是在单链表的每个节点中，再设计一个指向直接前驱的指针域，所以一个双向链表具有两个指针域，一个指向直接前驱，一个指向直接后继。
 

双向链表定义示例： 

typedef int TYPE;
typedef struct node //单链表结构体
{
    TYPE date;
    struct node *next; //指向直接后继
    struct node *prev; //指向直接前驱
}Node;
typedef struct head
{
    int num;
    struct node *first; //头
    struct node *tail; //尾
}Head;

 双向链表元素插入示例： 

/**
* dlk:双向链表管理
* x：插入元素
* n：插入方式 1：头插 2：尾插 3：升序插入
*/
void insert_double_linkedist(Head *dlk,int x,int n) //插入元素到链表
{
    if(dlk==NULL)
        return;
    Node *p=(Node*)malloc(sizeof(Node));
    p->date=x;
    p->next=NULL;
    p->prev=NULL;
    if(n==1)
    {
        if(dlk->num==0) //插入的为首个元素
        {
            dlk->first=p;
            dlk->tail=p;
        }
        else
        {
            dlk->first->prev=p;
            p->next=dlk->first;
            dlk->first=p;
        }
        (dlk->num)++;
    }
    else if(n==2)
    {
        if(dlk->num==0) //插入的为首个元素
        {
            dlk->first=p;
            dlk->tail=p;
        }
        else
        {
            dlk->tail->next=p;
            p->prev=dlk->tail;
            dlk->tail=p;
        }
        (dlk->num)++;
    }
    else if(n==3)
    {
        if(dlk->num==0) //插入的为首个元素
        {
            dlk->first=p;
            dlk->tail=p;
            (dlk->num)++;
            return;
        } 
        Node *q=dlk->first; //用于找到插入位置
        while (q)
        {
            if(q->date>=p->date)
            {
                if(q->prev != NULL)
                    q->prev->next=p;
                p->prev=q->prev;
                p->next=q;
                q->prev=p;
                break;
            }
            p=p->next;
        }
        if(q == NULL) //说明待插入元素比链表中所有元素大，插入在链表末尾
        {
            dlk->tail->next=p;
            p->prev=dlk->tail;
            dlk->tail=p;
        }
        (dlk->num)++;
        return; 
    }
    else
        return;
}
双向链表元素删除示例： 
void delete_all(Head *dlk,TYPE x) //删除一个无序链表中指定的值
{
    if(dlk==NULL||dlk->num==0)
        return;
    Node *p=dlk->first;
    while (p)
    {
        Node *t=p;
        if(p->date==x)
        {
            if(p->prev != NULL)
                p->prev->next=p->next;
            if(p->next != NULL)
                p->next->prev=p->prev;
            p=p->next;
            (dlk->num)--;
            free(t);
            continue;
        }
        p=p->next;
    }
}
九月丫
关注
专栏目录
数据结构-线性表的基本操作
qq_47911588的博客
06-29 2931
本文介绍我在学习数据结构的过程中如何利用线性表编写算法解决实际问题的方法线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。......
数据结构-线性表（代码，巨详细
weixin_51460943的博客
04-16 3035
单链表 不带头节点的单链表（基本操作） 1. 创建 //单链表不带头结点 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data; struct LNode *next; }LNode, * LinkList; LinkList initList(LinkList list){ list=NULL; return list; } 2. 插数据 //插数据（第一个位置）（指定位置）
数据结构-线性表-思维导图+小结
学习记录
11-12 2496
数据结构-线性表-思维导图+习题小结
数据结构 -线性表
weixin_59725429的博客
11-06 1468
线性表 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。线性表长度：线性表中元素的个数。线性表L=（a1,a2,a3……
数据结构-线性表及顺序存储结构
2301_81798038的博客
09-24 1006
线性表是具有相同特征的数据元素的一个有限序列（可以参考数组理解）。其中n为表长，当n = 0时线性表是一个空表。在线性表中每个数据元素有逻辑序号唯一确定，设序列中的第i（ i 表示逻辑序号）个元素为ai(1 <= i <= n),则线性表的一般表示为a1是表头元素，an是表尾元素。
数据结构 - 线性表（C语言版）
weixin_41733225的博客
07-11 2358
主要讲述顺序表和单链表的基础操作
数据结构-线性表的链式表示
pyc68的博客
06-25 1240
本篇文章主要介绍线性表的链式表示
初始数据结构-线性表
weixin_44448217的博客
03-30 1449
线性表 一：什么是线性表 线性表全名线性存储结构，是最基本、最简单、也是最常用的一种数据结构。 二：线性表的特点 存储的数据本身的类型一定保持相同，是int型就都是int型，是结构体就都是一种结构体。（方便寻址） 数据一旦用线性表存储，各个数据元素之间的相对位置就固定了。 三：线性表分类 顺序表，链表，栈，队列 1：顺序表 顺序表是线性表的一种，其特点是顺序表在物理层上的存储是连续的。 数组是最常见的线性表 1.初始化 2.插入元素 ​ 在下标为2的地方插入一个6 3.删除元素 这样的存储
【数据结构-线性表】
2302_80393814的博客
06-29 938
线性表是由n（n≥0）个数据元素组成的有限序列，这些元素排列在一个线性的序列中。每个元素最多只有一个直接前驱和一个直接后继。线性表可以为空表，即不包含任何元素。实现方式有顺序存储和链式存储。线性表是一种简单而实用的数据结构，它支持快速的插入、删除、查找和遍历操作，适用于各种应用场景。通过示例，我们深入理解了线性表的基本操作，并展示了如何实现和使用这些操作来管理数据。希望本文能够帮助读者更好地理解和应用线性表这一基础数据结构！
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
2.C-数据结构-线性表-线性表源码
09-07
2.C-数据结构-线性表-线性表源码
2.C-数据结构-线性表-链表源码
09-07
2.C-数据结构-线性表-顺序表源码
2.C-数据结构-线性表-顺序表源码
08-30
2.C-数据结构-线性表-顺序表源码
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
数据结构-二叉树及其遍历
最新发布
宁zz的博客
11-15 562
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
数据结构-递归函数的调用栈过程
qq_52291558的博客
11-12 228
这道题考察的是递归函数的调用栈过程。
数据结构 ——— 层序遍历链式二叉树
weixin_55341642的博客
11-13 625
利用队列先进先出的性质实现层序遍历链式二叉树
数据结构-二叉搜索树（Java语言）
NoobNo2的博客
11-15 767
个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即。在最后删除target节点的时候，要判断target节点是在targetparent的左边还是右边。同时用parent节点记录cur的父节点，最终用parent的val与key作比较，，用它的值填补到被删除节点中，再来处理该结点的删除问题。如果cur节点val==key，返回该节点。
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

九月丫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值