顺序表

顺序表

顺序表——用顺序存储的方式实现线性表

顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的领接关系来体现。

顺序表的实现——静态分配

#define MaxSize 10          //定义最大长度
typedef struct
{
    ElemType data[MaxSize]; //用静态的“数组”存放数据元素
    int length;             //顺序表的当前长度
}SQList;                    //顺序表的类型定义（静态分配方式）

data：数组代表一共能存多少个数据

length：代表现在数组中有多少个元素

#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;        //将所有数据元素设置为默认初始值0
    }
    L.length=0;             //顺序表初始长度为0
}
int main(){
    SqList L;               //声明一个顺序表
    InitList(L);            //初始化顺序表
    for(int i=0;i<MaxSize;i++){
        printf("data[%d]=%d\n",i,L.data[i]);
    }
    return 0;
}

运行结果：

如果不初始化data数组：

void InitList(SqList &L){
    L.length=0;             //顺序表初始长度为0
}

内存中会有遗留的脏数据，这些内存之前存的数据我们不知道，不初始化容易获取脏数据

在正常情况下遍历的范围不应该超过数据的数量

 for(int i=0;i<L.length;i++){
        printf("data[%d]=%d\n",i,L.data[i]);
    }

问题：如果“数组”存满了怎么办？

A:可以放弃治疗，顺序表的表长刚开始确定后就无法更改（存储空间是静态的）

思考：如果刚开始就声明很大的内存空间？存在什么问题？很浪费

顺序表的实现——动态分配

#define InitSize 10         //顺序表的初始长度
typedef struct{
    ElemType *data;         //指示动态分配数组的指针
    int MaxSize；           //顺序表的最大容量
    int length；            //顺序表的当前长度
}SeList;                    //顺序表的类型定义（动态分配方式）

Key:动态申请和释放内存空间

C——malloc、free函数

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

malloc函数返回一个指针，需要强制转型为你定义的数据元素类型指针（InitSize，指明要分配多大的连续内存空间）

C++ ——new、delete关键字

#include<stdio.h>
#include<stdlib.h>
#define InitSize 10         //顺序表的初始长度
typedef struct{
    int *data;              //指示动态分配数组的指针
    int MaxSize;           //顺序表的最大容量
    int length;            //顺序表的当前长度
}SeList;                    //顺序表的类型定义（动态分配方式）
void InitList(SeList &L){
    //用malloc函数申请一片连续的存储空间
    L.data = (int *)malloc(InitSize*sizeof(int));
    L.length = 0;
    L.MaxSize=InitSize;
}
//增加动态数组的长度
void IncreaseSize(SeList &L,int len){
    int *p=L.data;
    L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
    for(int i=0;i<L.length;i++){
        L.data[i]=p[i];         //将数据复制到新区域
    }
    L.MaxSize = L.MaxSize+len;  //顺序表最大长度增加len
    free(p);                    //释放原来的内存空间
}
int main(){
    SeList L;               //声明一个顺序表
    InitList(L);            //初始化顺序表
    IncreaseSize(L,5);          //长度加5
    return 0;
}

顺序表的特点：

1. 随机访问，即可以在O(1)时间内找到第i个元素
2. 存储密度高，每个节点只存储数据元素
3. 拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高）
4. 插入、删除操作不方便，需要移动大量元素

总结