数据结构-王道2017-第2章 线性表

1. 线性表的定义和基本操作

  1.1 线性表的定义

    线性表电话i具有相同数据类型的n(n >= 0)个数据元素的有限序列。其中n为表长,当n=0时,该线性表是一个空表。若用L命名线性表,则一般表示为:

          L=(a1,a2,a3...ai,ai+1...an)

   其中,a1是唯一的第一个数据元素,又称为表头元素;an是唯一的最后一个数据元素,又称为表尾元素。除第一个元素外,每个元素有且仅有一个直接前驱。除最后一个元素外,每个元素有且仅有一个直接后继。以上就是线性表的逻辑特性,这种线性有序的逻辑结构正是线性表名字的由来。

      表中的个树有限

      表中元素具有逻辑上的顺序性,在序列中各元素排序有先后顺序。

      表中元素都是数据元素,每一个元素都是单个元素。

      表中元素的数据类型都相同。这意味着每一个元素占有相同大小的空间。

      表中元素具有抽象性。即仅讨论元素间的逻辑关系,不考虑元素究竟表示什么内容。

    注意:线性表是一种逻辑结构,表示元素之间一对一的相邻关系。顺序表和链表是指存储结构,两者属于不同层面的概念,因此不要将其混淆。

 1.2 线性表的基本操作

    一个数据结构的基本操作是指其最核心、最基本的操作。其他较复杂的操作可以通过调用其基本操作来实现。线性表的主要操作如下:

     InitList(&L)  : 初始化表。构造一个空的线性表。

     Length(L) : 求表长。返回线性表L的长度,即L中数据元素的个数。

     LocateElem(L,e): 按值查找操作。在表L中查找具有给定关键字值的元素。

     GetElem(L,i): 按位查找操作。获取表L中第i个位置的元素的值。

     ListInsert(&L,i,e): 插入操作。 在表L中第i个位置上插入指定元素e。

     ListDelete(&L,i,&e): 删除操作。 删除表L中第i个位置的元素,并用e返回删除元素的值。

     PrintList(L): 输出操作。按前后顺序输出线性表L的所有元素值。

     Empty(L) : 判空操作。若L为空表,则返回true,否则返回false.

   注意:基本操作的实现取决于采用哪一种存储结构,存储结构的不同,算法的实现也不同。

           线性表的定义要求为有限序列,并且具有逻辑上的联系。

           集合中个元素没有前后驱关系,因此不是线性表。

           邻接表是一种存储结构,而线性表是一种逻辑结构。

  2. 线性表的顺序表示

     2.1 线性表的顺序存储又称为顺序表。它是用一组地址连续的存储单元,依次存储线性表中的数据元素。

      假设线性表L存储的起始位置为LOC(A),sizeof(ElemType)是每个数据元素所占用存储空间的大小。

      假定线性表的元素类型为ElemType,线性表的顺序存储类型描述为

 #define MaxSize 50      //定义数据表的最大长度

       typedef struct{

          ElemType data[MaxSize];     //顺序表的元素

          int length;      //顺序表的当前长度

       }SqList;          //顺序表的类型定义

  一维数组可以是静态分配的,也可以是动态分配的。在静态分配时,由于数组的大小和空间实现已经固定,一旦空间占满,再加入新的数据将产生溢出,就会导致程序崩溃。

 而动态分配时,存储数组的空间是在程序执行过程中通过动态存储分配语句分配的,一旦数据空间占满,可以另外开辟一块更大的存储空间,用以替换原来的存储空间。从而达到扩充存储数组空间的目的。

  

 #define InitSize 100                    //表长度的初始定义

   typedef struct{

      ElemType *data;               //指示动态分配数组的指针

      int MaxSize,length;          //数组的最大容量和当前个数

   }SeqList;                       //动态分配数组顺序表的类型定义

  c的初始动态分配语句:

    L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);

   C++的初始动态分配语句为:

     L.data = new ElemType[InitSize];

      注意: 动态分配并不是链式存储,同样还是属于顺序存储结构,其物理结构没有变化,依然是随机存储方式,只是分配的空间大小可以在运行时决定。

   2.2 顺序表基本操作的实现

     (1)插入操作

           在顺序表L的第i(1<=i<=L.length+1)个位置插入新元素e。如果i的输入不合法,则返回false,表示插入失败;否则,将顺序表的第i个元素以及其后的所有元素右移一格位置,腾出一个空位置插入新元素e,顺序表长度增加1,插入成功,返回true.(C++ 按引用传参)

       

   bool ListInsert(SqList &L, int i, ElemType e){

              if(L.length >= MaxSize)                   //当前存储空间已满

                    return false;

              if(1<=i && i <= L.length + 1){

                   for(int j = L.length;j >= i;j-- )

                         L.data[j] = L.data[j - 1];

                    L.data[i-1] = e;                                   //位置i的下标为i-1,也就是在位置i处放入e,可以在末尾插入

                    L.length++;

                    return true;

               }else{

                   return false;

               }
          }  

             最好情况: 在表尾插入,即i=n+1,元素后移语句不执行,时间复杂度为O(1);

             最坏情况: 在表头插入(即i=1),元素后移语句将执行n次,时间复杂度为O(n);

             平均情况: 假设pi(pi=1/(n+1))是在第i个位置上插入一个结点的概率,则在长度为n的线性表中插入一个节点时所需移动节点的平均次数为 n/2.

       (2)删除操作

             删除顺序表L中第i(1<=i<= L.length) 个位置的元素,成功返回true,并将被删除的元素用引用变量e返回,否则返回false。

              bool ListDelete(SqList & L, int i, ElemType &e){

                     if(1 > i || L.length < i)

                             return false;

                     e = L.data[i-1];

                     for(int j = i;j <L.length;j++)

                             L.data[j-1] = L.data[j];

                     L.length--;

                     return true;

               }  

               最好情况删除队尾元素,无需移动,时间复杂度为O(1);

               最坏情况,删除表头元素,需要移动n-1次,时间复杂度为O(n)    

               平均情况: 所需移动节点的平均次数为: (n-1)/2;  O(n)

        (3) 按值查找

              在顺序表L中查找第一个元素值为e的元素,并返回其位序.

              int LocatElem(SqList L,ElemType e){

                   for(int i = 0;i < L.length;i++){

                        if(L.data[i] == e)

                             return i+1;

                   }

                   return 0;                 //没找到

              }        

             最好:在表头,仅需比较一次,时间复杂度为O(1);

             最差:在末尾或不存在,为n次,O(n)

             平均 n+1/2  

   

   

原文地址:https://www.cnblogs.com/--CYH--/p/6533419.html