数据结构入门学习系列-3（线性表的顺序存储）

      空间复杂度：算法写成程序后，运行时占用的电脑内存空间。S（n）=O（f（n））

    这个比较好理解，比如一维数组a
占用空间复杂度是：S（n）=O(n),

                                 二维数组a
[m]占用空间复杂度是：S(n)=O(n*m)

    线性结构中的线性表：存在唯一的第一个元素和最后一个元素。除了这两个特殊数据之外，中间元素都有一个直接前驱和一个直接后继。

     一个简单的抽象模型：

     ADT List{

              数据对象

              数据关系

              基本操作：init    insert   delete......

     }ADT List

     其中线性结构根据存储方式不同有以下几种：

     1.顺序存储（数组），通过抽象语言简单定义一下：

 

#include<stdio.h>
#define OK 1
#define ERROR -1
#define MAX_SIZE 100
typedef int Status
typedef int ElemType
typedef struct sqlist{
ElemType elem_array[MAX_SIZE];
int length;
}SqList;

     对于该线性结构初始化;

/初始化
Status Init_SqList(SqList *l)
{
l->elem_array = (ElemType *)malloc(MAX_SIZE*sizeof(ElemType));
if(!l->elem_array){
printf("申请空间失败！");
return ERROR;
} else{
l->length = 0;
return OK;
}
}

    之后进行在i的位置插入一个元素e的操作：

//在第i个位置插入元素e
Status Insert_SqList(Sqlist *l, int i, ElemType e)
{
int j;
if(i<0 || i>MAX_SIZE){
printf("i 超出数组最大长度");
return ERROR;
}
if(l->length > MAX_SIZE){
printf("数据溢出");
return ERROR;
}
for(j=l->length-1;j>=i-1;j--){
l->elem_array[j+1]=l->elem_array[j];
l->elem+array[i-1]=e;
}
l->length++;
}

    该线性表的插入运算需要将i之后的元素都往后移一位，然后在i的位置插入。

     时间复杂度：一般情况下，插入某个点的概率为p=1/(n+1),需要做的操作次数为：q=n-i+1.由此可以计算i从0到n的插入可能操作次数为i从0到n的p*q的和。预算后是n/2，也就是O（n）。

    下面来看删除的操作，删除分两种方法，一种是删除掉i位置的元素，一种是删除元素值为e的元素。

     删除掉i位置的元素：

//删除固定位置i的一个元素
Status Delete_SqList(SqList *l, int i)
{
int j ;
ElemType x;
if(l->length = 0)
return ERROR;
if(i>MAX_SIZE && i<0)
return ERROR;
x=l->elem_array[i-1];
for(j=i;j<l->length;j++)
l->elem_array[j-1]=l->elem_array[j];
l->length--;
return x;
}

    根据之前插入函数的算法，改程序的时间复杂度也是O（n）。

     删除元素值为e的元素：

//删除元素e
Status Locate_Delete_SqList(SqList *l, ElemType e)
{
int i,j;
while(i<l->length){
if(l->elem_array[i]!=x)
i++;
for(j=i+1;j<=l->length;j++)
l->elem_array[j-1]=l->elem_array[j];
l->length--;
break;
}
if(i>=l->length)
return ERROR;
}

删除的时候需要先查找，再讲找到的位置的元素之后往前一次平移一位。由之前的计算：比较查找的时间复杂度为：（n+1）/2,平移的时间复杂度是：（n-1）/2。所以最终复杂度为O（n）。