数据结构学习（五）：线性表的顺序存储结构

一、线性表的顺序存储结构：顺序表

      把线性表中的所有元素按照顺序存储方法进行存储
      按逻辑顺序依次存储到存储器中一片连续的存储空间中

二、顺序表类型定义（SqList）

typedef struct
   {    ElemType   data[MaxSize];
        int length;
   }SqList;                 //顺序表类型
   data成员存放元素，length成员存放线性表的实际长度
   注意：逻辑位序和物理位序（在data数组中的下标）相差为1

三、顺序表运算的实现

（1）建立顺序表 CreateList(L)

 void CreateList(SqList *&L, ElemType a[], int n)
      //整体建立顺序表
   {  
      int i;
      L=(SqList *)malloc(sizeof(SqList));
      for(int i=0;i<n;i++)
               L->data[i]=a[i];
       L->length=n;
    }

（2）初始化线性表 InitList(L)

该运算结果是构造一个空的线性表L，实际上只需要将length成员设置为0即可

 void InitList(SqList * &L)
 {
    L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的顺序表空间
    L->length=0;
 }

（3）销毁线性表 DestroyList(L)

      该运算的结果是释放线性表L占用的内存空间

  void  DestroyList(SqList  *&L)
  {
       free(L);  //释放L所指向的空间
  }

（4）判断是否为空表 ListEmpty(L)

    该运算返回一个值表示L是否为空表。若L为空表，则返回true,否则返回false

  bool ListEmpty(SqList *L)
 {
       return(L->length == 0);
 }

(5)求线性表的长度 ListLength(L)

   该运算返回顺序表L的长度。实际上只需要返回length成员的值即可

   int  ListLength(SqList *L)
   {
        return(L->length);
   }

（6）输出线性表 DispList(L)

   该运算当线性表L不为空时，顺序表显示L中各元素的值

   void  DispList(SqList *L)
   {
       int i;
       if ( ListEmpty(L) )    return ;
       for(i=0;i<L->length;i++)
                  printf("%c",L->data[i] );
       printf("\n");
    }

（7）求某个数据元素值 GetElem(L,i,e)

    该运算返回L中第i（1<=i<=ListLength(L)）个元素的值，存放在e 中

        bool GetElem(SqList * L, int i, ElemType &e)
        {
              if(i<1 || i>L->length)   return false;
              e=L->data[i-1];
              return true;
        }
       //算法时间复杂度为O(1)---体现顺序表的随机存取特性

（8）按元素值查找 LacateElem(L,e)

    该运算顺序查找第1个值域与e相等的元素的逻辑位序。若这样的元素不存在，则返回值为0

int LocateElem(SqList *L,  ElemType e)
{
      int i=0;
      while(i<L->length && L->data[i]!=e )
                i++;
      if(i>=L->length)  return 0;
      else  return i+1;
 }

（9）插入数据元素ListInsert(&L,i,e)

     该运算在顺序表L的第 i (1<=i<=ListLength(L)+1)个位置上插入新的元素e

 bool ListInsert(SqList *&L, int i,ElemType e)
 {
       int j;
       if(i<1 || i>L->length+1)    
               return false;  //参数错误时返回false
       i--;     //将顺序表逻辑序号转化为物理序号                                                      
       for(j=L->length ; j>i;j--)                  
       //将data[i...n-1]元素后移一个位置
                 L->data[j]=L->data[j-1];
       L->data[i]=e;              //插入元素e
       L->length++;              //顺序表的长度增1
       return   true;            //成功插入返回true
  }

对于本算法元素移动的次数不仅与表长L->length=n有关，而且与插入位置i有关

 A、当i=n+1时，移动次数为0------算法最好时间复杂度为O(1)
 B、当i=1时，移动次数为n,达到最大值-----算法最坏时间复杂度为O(n)
 C、插入一个元素所需要移动元素的平均次数为：n/2------平均时间复杂度为O(n)

(10)删除数据元素 ListDelete(&L,i,e)

     该运算删除顺序表L的第 i (1<=i<=ListLength(L))个元素

 bool ListDelete(SqList *&L, int i,ElemType  &e)
 {
     int j;
     if(i<1 || i>L->length)    return false;  //参数错误时返回false
     i--;              //将顺序表逻辑序号转化为物理序号
     e=L->data[i];
     for(j=i; j=L->length-1 ; j++)   //将data[i...n-1]元素前移
              L->data[j]=L->data[j+1];
     L->length--;               //顺序表的长度减1
     return   true;             //成功删除返回true
  }

对于本算法元素移动的次数不仅与表长L->length=n有关，而且与插入位置i有关

 A、当i=n时，移动次数为0------算法最好时间复杂度为O(1)
 B、当i=1时，移动次数为n-1,达到最大值-----算法最坏时间复杂度为O(n)
 C、删除一个元素所需要移动元素的平均次数为：(n-1)/2------平均时间复杂度为O(n)