数据结构之线性表

前言

❝

提到数据结构，可能会有很多人马上联想到栈，队列，树，哈希表，图等各种经常提到的数据结构，但是我们去忽略了本质，这些都是抽象的逻辑结构，追本溯源，数据结构中的存储方式只有两种：数组(顺序存储)和链表(链式存储)，而上述我们所提到的多样化的数据结构，都是在数组或链表上的一系列特殊操作。

❞

今天我们提到的线性表可以通过数组或链表来实现，至于到底选哪个实现，根据不同的需求而定，二者并没有好坏之分，适合的才是最好的。本篇文章将详细叙述C语言用数组和链表的方式来实现线性表这种数据结构。从而理解顺序存储与链式存储的区别，可能大家比较疑惑为什么实现数据结构都是用c语言，还是那句话，语言不是关键，思想才最重要，而且像Java中已经自带了集合类，ArrayList和LinkedList，还有特殊的线性表如Stack类，直接去看源码即可！

线性表：零个或多个数据元素的「有限」序列。

抽象数据类型定义

ADT 线性表Data  线性表的数据对象集合为{a1,a2,......an},每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。Operation InitList(*L);  初始化操作 ListEmpty(L);  返回值True和False，判断线性表是否为空 ClearList(*L); 清空线性表 GetElem(L,i,*e); 将线性表L中的第i个位置元素值返回给e。 LocateElem(L,e); 在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表中序号表示成功，否则，返回0表示失败。 ListInsert(*L,i,e);在线性表中的第i个位置插入新元素e。 ListDelete(*L,i,*e);删除线性表L中的第i个位置，并用e返回其值。 ListLength(L);返回线性表L的元素个数。endADT

Tips：大多数数据结构，其实我们可以发现「增删改查」是很必要的操作。改的操作其实也可理解为「插入」+「删除」！

顺序存储结构(数组)

线性表的顺序存储结构，就是在内存中找了块地，通过占位的形式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空地中。可以采用C语言的一维数组实现顺序存储结构。

为了减少性能上的损耗，这里我们不采用动态数组的方式，所以应该保证任意时刻，「线性表的长度应该小于数组的长度。」

结构代码

#define MAXSIZE 20  //储存空间分配初始量typedef int ElemType;    //假设为int类型typedef struct{    ElemType data[MAXSIZE];  //数组存储数据元素，最大值为MAXSIZE    int length;  //线性表当前的长度}cList;

三个属性：

• 数组data：存储空间的存储位置
• 线性表最大存储量：数组长度MAXSIZE；
• 线性表当前长度：length

定义函数类型Status，其值是函数结果的状态码

#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef int Status;         /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

获得元素操作

思路分析：因为数组有下标，只需插入的元素在数组的下标范围内，把数组[插入元素位置-1]下标的值返回即可。

时间复杂度：O(1)

Status GetElem(cList L,int i,ElemType *e){    if(L.length==0 || i<1 || i>L.length)            return ERROR;    *e=L.data[i-1];    return OK;}

插入元素操作

思路分析：假设一个只能排5个人的队伍，队伍容量为5即数组长度为5，队伍中人的现有个数为线性表长度，若想要插队时如果已经5人满就不能插入，若想插在第6个位置超出了队伍的容量范围，也不能插入，无上述情况下，插入元素身后后面的人都要往后挪一位，前面的人不受影响，最后队伍人现有个数加1。

时间复杂度：O(n)   最坏的情况下 【插在队首】

/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */Status ListInsert(cList *L,int i,ElemType e){ int k; if (L->length==MAXSIZE)  /* 顺序线性表已经满 */  return ERROR; if (i<1 || i>L->length+1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */  return ERROR; if (i<=L->length)        /* 若插入数据位置不在表尾 */ {  for(k=L->length-1;k>=i-1;k--)  /* 将要插入位置之后的数据元素向后移动一位 */   L->data[k+1]=L->data[k]; } L->data[i-1]=e;          /* 将新元素插入 */ L->length++; return OK;}

删除元素操作

思路分析：与插入同样，不过是一个人有事离开后，队伍现有人数减1，离开人的后面的人往前挪一位。

时间复杂度：O(n)   最坏的情况下【第一个人离开】

Status ListDelete(cList *L,int i,ElemType *e){    int k;    if (L->length==0)               /* 线性表为空 */  return ERROR;    if (i<1 || i>L->length)         /* 删除位置不正确 */        return ERROR;    *e=L->data[i-1];    if (ilength)                /* 如果删除不是最后位置 */    {for(k=i;klength;k++)/* 将删除位置后继元素前移 */   L->data[k-1]=L->data[k];    }    L->length--;return OK;}

优点

• 元素只包含数据，不需要其他额外空间
• 根据索引可以迅速存取表中任一位置元素(查的快)

缺点

• 插入和删除元素需要移动大量元素(改删慢)
• 线性表长度变化较大时，难以确定存储空间的容量(动态线性表不易确定)
• 造成存储空间的碎片

链式存储结构(链表)

为了解决顺序存储结构的缺点，我们发现，造成插入和删除元素慢的原因是为了保证连续，我们不得不移动大量元素，这个操作可不可以避免呢？因此，就有了链式存储这个结构。

链式结构规定了数据元素不一定连续，甚至可以是零散分布在内存中的任意位置上，因此不需要先估计存储空间大小，解决了顺序存储难以确定存储空间容量大小的缺点。

在逻辑关系上，我们可以看成这种形式：

举个简单例子-在医院排队等号时，你只需要知道你前一个是多少号，等前一个号叫到了，你才知道马上该到你了，排队期间你可以去任意地方，顺序存储是你必须要站在队伍中排队，从而，你前边插了多少人，中途离开了多少人，你都是不知道的，因此很好的弥补了顺序存储增删慢的缺点。

在链式结构中，除了要存储元素信息外，还要存储后继元素的地址。

存储数据元素信息的域称为数据域，把直接存储后继位置的域称为指针域，两部分信息合称为结点(Node)。

链表中第一个结点的存储位置叫做头指针，最后一个结点指针为空Null。

单链表中，我们在C语言中可用「结构指针」来描述

/*线性表的单链表存储结构*/typedef struct Node{    ElemType data;    struct Node *next;}Node;typedef struct Node *LinkList; /* 定义LinkList */

获得元素操作

思路分析：

• 声明一个结点p指向第一个结点，初始化一个变量j从1开始作为计数器
• 当j小于要获得的第i个元素，遍历链表，让p的指针向后移动，指向下一结点，j累加。
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找为空，返回结点p的数据。

Tips：由于单链表结构中没有定义表长，所以不方便用for来循环控制

时间复杂度：O(n) 最坏情况下【获得最后一个元素】

/* 操作结果：用e返回L中第i个数据元素的值 */Status GetElem(LinkList L,int i,ElemType *e){ int j; LinkList p;  /* 声明一结点p */ p = L->next;  /* 让p指向链表L的第一个结点 */ j = 1;  /*  j为计数器 */ while (p && j/* p不为空或者计数器j还没有等于i时，循环继续 */ {     p = p->next;  /* 让p指向下一个结点 */  ++j; }if ( !p || j>i ) return ERROR;  /*  第i个元素不存在 */ *e = p->data;   /*  取第i个元素的数据 */return OK;}

插入元素操作

思路分析：

• 声明一结点p指向链表第一个结点，初始化j从1开始。
• 当j
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找成功，在系统中生成一个空结点s。
• 将数据元素e赋值给s->data。
• 单链表的插入标准语句 s->next = p->next; 与  p->next = s;

Tips：s->next = p->next; 与  p->next = s;  顺序不可以交换，交换后就变成了s->next = s;

时间复杂度：O(n)

/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */Status ListInsert(LinkList *L,int i,ElemType e){  int j; LinkList p,s; p = *L;    j = 1; while (p && j /* 寻找第i个结点 */ {  p = p->next;  ++j; }  if (!p || j > i)   return ERROR;   /* 第i个元素不存在 */ s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */ s->data = e;   s->next = p->next;      /* 将p的后继结点赋值给s的后继  */ p->next = s;          /* 将s赋值给p的后继 */ return OK;}

删除元素操作

思路分析：

• 声明一结点p指向链表第一个结点，初始化j从1开始。
• 当j
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找成功，将要删除的结点的指针p->next赋值给q;
• 单链表的删除标准语句p->next=q->next;
• 将q结点中的数据赋值给e，作为返回；
• 释放q结点；(系统回收q结点，释放内存)

Tips：由于单链表结构中没有定义表长，所以不方便用for来循环控制

时间复杂度：O(n)

/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */Status ListDelete(LinkList *L,int i,ElemType *e) {  int j; LinkList p,q; p = *L; j = 1; while (p->next && j /* 遍历寻找第i个元素 */ {        p = p->next;        ++j; } if (!(p->next) || j > i)      return ERROR;           /* 第i个元素不存在 */ q = p->next; p->next = q->next;   /* 将q的后继赋值给p的后继 */ *e = q->data;               /* 将q结点中的数据给e */ free(q);                    /* 让系统回收此结点，释放内存 */ return OK;}

通过上述代码我们可以看到，插入和删除的时间复杂度(最坏情况)并没有明显的降低，那为什么说链表插入和删除快呢？通过分析我们发现，在链表的插入与删除的操作中，都进行了一次查找，对于频繁插入或删除的数据，在一次查询后，知道了结点的位置后，后续我们在进行增删的操作的时间复杂度仅仅是O(1)了！

优点

• 单链表在查找后某位置的指针后，插入和删除时间复杂度仅为O(1)。
• 不需要预先分配存储空间，元素个数理论上不受限制。

缺点

• 查询元素变慢
• 额外的空间去存储地址

想看更多，扫码关注我

微信号｜hhl_1393603513

扫码关注

点击蓝字

关注我们