数据结构与算法学习笔记-线性表（2）

2.2线性表的实现

2.2.1线性表的顺序存储

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

用这种方法存储的线性表简称顺序表

顺序存储的线性表的特点：

• 线性表的逻辑顺序与物理顺序一致；
• 数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。

设每个元素需占用/个存储单元，以所占的第一个单元的存储地址作为数据元素的存储位置。则线性表中第i+1个数据元素的存储位置LOC（ai+1）和第i个数据元素的存储位置LOC（ai）之间满足下列关系：

​ LOC（ai+1） = LOC（ai）+ /

线性表的第i个数据元素ai的存储位置为：

​ LOC（ai） = LOC（a1）+（i-1）* /

存取结构：存取结构是在一个数据结构上对查找操作的时间性能的一种描述

• 随机存取结构：指在一个数据结构上进行查找的时间性能是O（1），即查找任意一个数据元素的时间是相等的，均为常数时间；

  （顺序表是一种随机存储结构）

• 顺序存取结构：指在一个数据结构上进行查找的时间性能是O（n），即查找一个数据元素的时间复杂度是线性的，与该元素在结构中的位置有关。

  （单链表是一种顺序存取结构）

  数组具有随机存取的特性，顺序表还应该有表示线性表的长度属性，所以用结构类型来定义顺序表类型。

  （1）静态结构：表一旦装满，不能扩充

#define MAX_SIZE 100
typedef int Status;
typedef int ElemType;
typedef struct sqlist{
    ElemType Elem_array[MAX_SIZE];
    int length;
}sqList;

​

​ （2）动态结构：可以扩充，新的大小计入数据成员maxSize中

typedef struct sqlist{
	ElemType *elem;//存储数组
    int length;//当前表元素个数
    int maxSize；//表的最大长度
}sqList；

顺序线性表的插入

​ 在线性表L = （a1，…ai-1，e，ai，ai+1，…，an）

实现步骤：

（1）将线性表L中的第i个至第n个结点后移一个位置；

（2）将结点e插入到结点ai-1之后；

（3）线性表长度加1。

如下图所示：

Status Insert_SqList(Sqlist *L,int i,ElemType e){
    int j;
    if (i<0||i>L->length-1)  return ERROR;
    if (L->length>=MAX_SIZE){
        printf("溢出！\n");return ERROR;
    }
    for (j=L->length-1;j>=i-1;--j)
        L->Elem_array[j+1] = L->Elem_array[j];
    /*  i-1位置以后的所有结点后移  */
    L->Elem_array[i-1] = e;/*  在i-1个位置插入  */
    L->length++;
    return OK;
}

时间复杂度分析

线性表L中的第i个元素之前插入新结点，结点的移动次数来估计算法的时间复杂度。

设在线性表L中的第i个元素之前插入结点的概率为Pi，不失一般性，设各个位置插入是等概率，则Pi = 1/（n+1），而插入时移动结点的次数为n-i+1。

总的平均移动次数：E（Insert） = ε pi *（n-i+1）（1<=i<=n）

​ 所以：E（Insert） = n / 2 。

即在顺序表上做插入运算，平均要移动表上的一半结点。当表长n较大时，算法的效率相当低。

因此算法的平均时间复杂度为O（n）。

顺序线性表的删除

在线性表L = （a1，…，ai-1，ai，ai+1，…，an）中删除结点ai（1<=i<=n），使其称为线性表：

​ L = （a1，…，ai-1，ai+1，…，an）

实现步骤：

（1）将线性表L中的第i + 1个至第n个结点依次向前移动一个位置。

（2）线性表长度减1。

如下图所示：

ElemType Delete_sqList(Sqlist *L,int i){
    int k;ElemType x;
    if (L->length==0){
        printf("线性表L为空！\n");
        return ERROR;
    }
    else if(i<1||i>L->length){
        printf("要删除的数据元素不存在！\n")；
            return ERROR;
    }
    else {
        x=L->Elem_array[i-1];
        /*保存结点的值*/
        for (k=i;k<L->length;k++)
            L->Elem_array[k-1]=L->Elem_array[k];
        /*i位置以后的所有结点前移*/
        L->length--;
        return (x)
    }
}

时间复杂度分析

设在线性表L中删除第i个元素的概率为Pi，不失一般性，设删除各个位置是等概率，则Pi=1/n，而删除时移动结点的次数为n-i。

总的平均移动次数：E（delete）= ε pi * （n-i） （1<=i<=n）

​ 所以：E（delete）= （n-1）/ 2。

即在顺序表上做删除运算，平均要移动表上一半 结点。当表长n较大时，算法的效率相当低。

因此算法的平均时间复杂度为O（n）。

顺序线性表的查找定位删除

在线性表 L = （a1，a2，… ，an）中删除值为x的第一个结点。

实现步骤：

（1）在线性表L查找值为x的第一个数据元素。

（2）将从找到的位置至最后一个结点依次向前移动一个位置。

（3）线性表长度减1。

Status Locate_Delete_sqList(Sqlist *L,ElemType x)
    /*删除线性表中值为x的第一个结点*/
{
   int i=0,k;
    while (i<L->length) /*查找值为x的第一个结点*/
    {
        if （L-> Elem_array[i]!=x）i++;
        else{
            for (k=i+1;k<L->length;k++)
                L->Elem_array[k-1]=L->Elem_array[k];
            L->length--;break; }
        if (i>L->length){
            printf("要删除的数据元素不存在！\n");
            return ERROR;}
        return OK;
    } 
}

时间复杂度分析-数据元素的比较和移动操作

首先，在线性表L中查找值为x的结点是否存在；

其次，若值为x的结点存在，且在线性表L中的位置为i，则在线性表L中删除第i个元素。

设在线性表L删除数据元素概率为Pi，不失一般性，设各个位置是等概率，则Pi = 1/n。

​ 比较的平均次数：E（compare） = ε Pi * i （1<=i<=n）

​ 所以：E（compare） = （n + 1）/ 2。

​ 删除时平均移动次数：E（delete）= ε Pi * （n - 1） （1<=i<=n）

​ 所以：E（delete）= （n-1） / 2。

平均时间复杂度：E（compare）+ E（delete） = n，即为O（n）。

例1：线性表的合并问题

已知顺序表LA和LB中的数据元素按值非递减有序排列，现要将LA和LB归并为一个新表LC，且LC中的数据元素仍按值非递减有序排列。

LA = （3，5，8，9） LB = （2，6，9，11，15，20）

LC = （2，3，5，6，8，9，9，11，15，20）

/*部分核心代码*/
void MergeList(SqList La,SqList Lb,SqList *Lc){
    1. pa = La.elem;pb = La.elem;
    2. Lc->listsize = Lc.length = La.length+Lb.length;
    3. Pc = Lc->elem = (ElemType*)malloc(Lc.listsize*sizeof(ElemType));
    4. if(!Lc.elem)  exit(overfiow);
    5. pa_last = La.elem + La.length-1;
    6. pb_last = Lb.elem + Lb.length-1;
    7. while(pa<=pa_last&&pb<=pb_last){
    8.    if (*pa<=*pb)
    9.        *pc++=*pa++;
    10.    else
    11.        *pc++=*pb++;}
    12. while(pa<=pa_last) *pc++=*pa++;
    13. while(pb<=pb_last) *pc++=*pb++;  }