线性表------顺序表的定义和操作

线性表定义

线性表是具有相同数据类型的n个数据元素的有限序列，其中n为表长

一、顺序表的定义

定义：用顺序存储的方式实现线性表顺序存储，把逻辑上的相邻的元素存储在物理位置上也相邻的存储单元中。

二、顺序表的实现–静态分配

#define MaxSize 10                
typedef struct{
             int data[MaxSize];        //用静态的数组存放数据元素
             int length ;
}Sqlist                                      //顺序表的类型定义（静态分配）

#include <stdio.h>
#define Maxsize 10

typedef struct
{
      int data[MaxSize];
      int length;
      
}Sqlist;

//基本操作  初始化一个顺序表
void InitList(Sqlist &L)
{
      for(int i=0;i<Maxsize;i++){
           L.data[i] = 0;
           L.length = 0;      
      }
}

int main()
{
    Sqlist L;            //声明一个顺序表
    
    InitList(L);	     //初始化顺序表
    
    //............
	return 0;
}

若静态分配中的数组存满了，则放弃“治疗”，顺序表的表长刚开始确定后就无法更改（存储空间是静态的）

三、顺序表的实现–动态分配

typedef struct
{
      int *data;    //动态分配数组的指针
      int MaxSize;  //最大容量
      int length;   //当前长度

}Seqlist;

#include <stdio.h>
#include <stdlib.h>

#define InitSize 10 //开始默认的最大长度
typedef struct
{
      int *data;    //动态分配数组的指针
      int MaxSize;  //最大容量
      int length;   //当前长度

}Seqlist;

//增加动态数组的长度
void IncreaseSize(Sqlist &L,int len)
{     
      int i;
      int *p = L.data;
      
      L.data = (int*)malloc( (L.MaxSize+len)*sizeof(int));
      for(i=0;i<L.length;i++){
          L.data[i] = p[i];      
      }
      
      L.MaxSize = L.MaxSize+len; //将数据复制到新区域
      free(p);                   //释放内存空间
}

void InitList(Seqlist &L)
{
     L.data = (int*)malloc(InitSize*sizeof(int));
     L.length = 0;
     L.MaxSize = InitSize;
}

int main()
{
     Sqlist L;
     
     InitList(L)
         //.....插入元素
     IncreaseSize(L,5);      
      
     return 0;
}

四、顺序表的特点：

1.随机访问
2.存储密度高，每个节点只存储数据元素
3.拓展容量不方便（即使是动态分配，拓展容量时间复杂度比较高）

五、顺序表的插入

注意：顺序表的位序是从1开始的，数组的下标是从0开始的

//在L的位序i处插入元素e
void ListInsert(Sqlist &L,int i,int e)
{     
     //将第i个元素及之后的元素后移
     for(int j=L.length;j>=i;j--){
         L.data[j] = L.data[j-1];
     }
         L.data[i-1] = e;   //在位置i处放入e
         L.length++         //长度加1
}

好的算法，应该具有“健壮性"，能处理异常情况，给使用者反馈

#define MaxSize 10
typedef struct{
      int data[MaxSize];    //静态分配创建顺序表
      int length;

}SqList;

bool ListInsert(SqList &L,int i,int e){
       if(i<1 || i>L.length+1){    //判断i值是否有效
          return false;       
       }
       if(L.length >= MaxSize){    //存储空间是否已满
          return false;       
       }
       
       for(j=L.length;j>=i;j--){
          L.data[j] = L.data[j-1];       
       }
       L.data[i-1] = e;
       L.length++'
       
       return true;

}

插入操作的时间复杂度

问题规模 n = L.length(表长)

六、顺序表的删除

bool ListDelete(SqList &L,int i,int &e)
{
       if(i<1 || i>L.length){
           return false;       
       }
       e = L.data[i-1];   //将被删除的元素赋给e
       
       for(int j=i;j<length;j++){  //将第i个元素后的元素前移
            L.data[j-1] = L.data[j];       
       }
        L.length--;
        return true;
}

删除操作的时间复杂度

七、顺序表的查找之按位查找

随机存取特性：由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和数据大小立即找到第i个元素

#define InitSize 10

typedef struct{
     int *data;    //动态分配数组的指针  malloc
     int MaxSize;
     int length;
}SeqList;

int GetElem(SeqList L,int i){
     return L.data[i-1];
}

时间复杂度：
O(1)

八、顺序表的查找之按值查找

#define InitSize 10

typedef struct{
     int *data;    //动态分配数组的指针  malloc
     int MaxSize;
     int length;
}SeqList;

//查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SeqList L,int e){
     for(int i=0;i<L.length;i++){
         if(L.data[i] == e){
            return i+1;         
         }     
     }
}

时间复杂度：