【数据结构】学习笔记之线性表

最新推荐文章于 2024-11-07 23:42:58 发布

大雨淅淅

最新推荐文章于 2024-11-07 23:42:58 发布

阅读量659

点赞数 5

CC 4.0 BY-SA版权

分类专栏： # 数据结构文章标签：数据结构学习笔记

本文链接：https://blog.youkuaiyun.com/xiaoyingxixi1989/article/details/142905924

数据结构专栏收录该内容

42 篇文章

订阅专栏

一、线性表基本概念

线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点））。

是由n(n≥0)个数据元素组成的有限序列。

        线性表的基本运算有：
        1）InitList(L),构造空表，即表的初始化；
        2）ListLength(L),求表的结点个数，即表长；
        3）GetNode(L,i),取表中第i个结点，要求1≤i≤ListLength(L)；
        4）LocateNode(L,x)查找L中值为x的结点并返回结点在L中的位置，有多个x则返回首个，没有则返回特殊值表示查找失败。
        5）InsertList(L,x,i)在表的第i个位置插入值为x的新结点，要求1≤i≤ListLength(L)+1；
        6）DeleteList(L,i)删除表的第i个位置的结点，要求1≤i≤ListLength(L)；

二、顺序表

顺序表：把线性表的结点按逻辑次序存放在一组地址连续的存储单元里。

顺序表结点的存储地址计算公式：Loc(ai)=Loc(a1)+(i-1)*C；1≤i≤n

2.1 顺序表插入

void insertlist(seqlist *L,datatype x,int i)
{
 int j;
 if(i<1||i>L->length+1)
  error(“position error”);
 if(L->length>=listsize)
  error(“overflow”);
 for(j=L->length-1;j>=i-1;j--)
  L->data[j+1]=L->data[j];  结点后移
 L->data[i-1]=x;
 L->length++;
}

在顺序表上插入要移动表的n/2结点，算法的平均时间复杂度为O(n)。

2.2 顺序表删除

void delete (seqlist *L,int i)
{
 int j;
 if(i<1||i>L->length)
  error(“position error”);
 for(j=i;j<=L->length-1;j++)
  L->data[j-1]=L->data[j];  结点前移
  L->length--;
}

在顺序表上删除要移动表的（n+1）/2结点，算法的平均时间复杂度为O(n)。

三、单链表

        单链表：只有一个链域的链表称单链表。
        在结点中存储结点值和结点的后继结点的地址，data next data是数据域，next是指针域。
        （1）建立单链表。时间复杂度为O(n)。
加头结点的优点：1）链表第一个位置的操作无需特殊处理；2）将空表和非空表的处理统一。
        （2）查找运算。时间复杂度为O(n)。

3.1 单链表按序号查找

Listnode * getnode(linklist head,int i)
{
 int j;
 listnode *p;
 p=head;j=0;
 while(p->next&&j<i){
  p=p->next; 指针下移
  j++;
 }
 if(i==j)
  return p;
 else
  return NULL;
}

3.2 单链表按值查找

Listnode * locatenode(linklist head ,datatype key)
{
 listnode *p=head->next;
 while(p&&p->data!=key)
  p=p->next;
 return p;
}

3.3 单链表插入运算

Void insertlist(linklist head ,datatype x, int i)
{
 listnode *p;
 p=getnode(head,i-1);
 if(p==NULL);
  error(“position error”);
 s=(listnode *)malloc(sizeof(listnode));
 s->data=x;
 s->next=p->next;
 p->next=s;
}

3.4 单链表删除运算

Void deletelist(linklist head ,int i)
{
 listnode *p ,*r;
 p=getnode(head ,i-1);
 if(p==NULL||p->next==NULL)
  error(“position error”);
 r=p->next;
 p->next=r->next;
 free(r);
}

四、循环链表

        循环链表：是一种首尾相连的链表。特点是无需增加存储量，仅对表的链接方式修改使表的处理灵活方便。
        空循环链表仅由一个自成循环的头结点表示。
        很多时候表的操作是在表的首尾位置上进行，此时头指针表示的单循环链表就显的不够方便，改用尾指针rear来表示单循环链表。用头指针表示的单循环链表查找开始结点的时间是O(1),查找尾结点的时间是O(n)；用尾指针表示的单循环链表查找开始结点和尾结点的时间都是O(1)。

在结点中增加一个指针域，prior|data|next。形成的链表中有两条不同方向的链称为双链表。

4.1 双链表的前插操作

时间复杂度为O(1)

Void dinsertbefore(dlistnode *p ,datatype x)
{
 dlistnode *s=malloc(sizeof(dlistnode));
 s->data=x;
 s->prior=p->prior;
 s->next=p;
 p->prior->next=s;
 p->prior=s;
}

4.2 双链表的删除操作

时间复杂度为O(1)。

Void ddeletenode(dlistnode *p)
{
 p->prior->next=p->next;
 p->next->prior=p->prior;
 free(p);
}

五、顺序表和链表的比较

基于空间的考虑：顺序表的存储空间是静态分配的，链表的存储空间是动态分配的。顺序表的存储密度比链表大。因此，在线性表长度变化不大，易于事先确定时，宜采用顺序表作为存储结构。
基于时间的考虑：顺序表是随机存取结构，若线性表的操作主要是查找，很少有插入、删除操作时，宜用顺序表结构。对频繁进行插入、删除操作的线性表宜采用链表。若操作主要发生在表的首尾时采用尾指针表示的单循环链表。

存储密度=（结点数据本身所占的存储量）/（整个结点结构所占的存储总量）
存储密度：顺序表=1，链表<1。