顺序表的使用

基本概念

定义：

1. 用顺序储存的方式实现线性表的顺序储存
2. 把逻辑上相邻的元素存储在物理位置上也相邻的储存单元中
3. 计算属性表元素的大小
4. sizeof(类名) sizeof（int）
5. 计算结构的大小 sizeof（SqList）

顺序表的特点：

1. 相同的数据类型 → 存储空间想通过
2. 数据元素有限且有次序
3. 其中n为表厂，n为0时线性表为空表
4. 位序:从1开始
5. 数组：从0开始
6. & 传入，c++专属操作

在C++中&的回执调用

#include <stdio.h>
#include <stdlib.h>
void test(int &x){
    x = 1024;
    printf("test函数内部 x=%d\n",x);

}
int main() {
    int x = 1;
    printf("调用test前 x=%d\n",x);
    test(x);
    printf("调用test后 x=%d\n",x);
    return 0;
}

实例

#include <stdio.h>

void test(int &x){
    x = 1024;
    printf("test函数内部 x=%d\n",x);

}
int main() {
    int x = 1;
    printf("调用test前 x=%d\n",x);
    test(x);
    printf("调用test后 x=%d\n",x);
    return 0;
}

顺序表的实现-静态分配

#include <stdlib.h>
#define MaxSize 10 //定义最大长度
typedef struct {
    ElemType data[MaxSize]; //用静态的“数组”存放数据元素
    int length; //顺序表的当前长度
}SqList; //顺便的类型定义（静态分配方式）
// 各个数据元素分配连续的存储空间，大小为：MaxSize*sizeof（ElemType）

完整实例

//顺序表的实现-静态分配：
#include <stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct {
    int data[MaxSize]; //用静态的“数组”存放数据元素
    int length; //顺序表的当前长度
}SqList; //顺便的类型定义（静态分配方式）




//基本操作-初始化一个顺序表
void InitList(SqList &L){
    for (int i = 0; i < L.length; i++) {
        L.data[i]=0; //将所有数据元素设置为默认的初始值
    L.length = 0;   //顺序表的初始长度为0
    }
}

int main(){
    SqList L; //声明一个顺序表
    InitList(L); //初始化顺序表
    //...未完待续，后续操作
    return 0;
}

顺序表的实现-动态分配

//顺序表的实现-动态分配；
#include <stdio.h>
#define  InitSize 10 //顺序表的初始长度
typedef struct {
    ElemType *data; //指示动态分配数组的指针
    int MaxSize; //顺序表的最大容量
    int length; //顺序表的当前长度
}SqList; //顺便的类型定义（动态分配方式）
// key：动态申请和释放内存空间；
//C------ malloc、free函数
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSIZE);
//C++ ----new、delete 关键字

完整实例

#include <stdlib.h> //malloc、free函数的头文件
//2.2-1
#define InitSize 10 //默认最大长度
typedef struct {
    int *data;  //指示动态分配数组的指针
    int MaxSize;    //顺序表的最大容量
    int length; //顺序表的当前长度
}SeqList;

void InitList(SeqList &L){
    //用 malloc 函数申请一片连续的存储空间
    L.data=(int*)malloc(InitSize*sizeof(int));
    L.length=0;
    L.MaxSize=InitSize;
}

//增加动态数组的长度 realloc也可以实现
void IncreaseSize(SeqList &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() {
    SeqList L;
    InitList(L);
    IncreaseSize(L,5);
    return 0;
}

顺序表的基本实现-插入

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

实例1

//顺序表的实现-静态分配：
#include <stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct {
    int data[MaxSize]; //用静态的“数组”存放数据元素
    int length; //顺序表的当前长度
}SqList; //顺序表的类型定义（静态分配方式）

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

    }
}
int main(){
    SqList L; //声明一个顺序表
    InitList(L);    //初始化顺序表
    //....此处省略插入
    ListInsert(L,3,3); //在表L中的第3个位置插入3
    return 0;
}