数据结构第二章线性表代码总结——顺序表

最新推荐文章于 2024-04-03 16:16:19 发布

orientation750

最新推荐文章于 2024-04-03 16:16:19 发布

阅读量505

点赞数 2

文章标签：数据结构算法

本文链接：https://blog.csdn.net/weixin_62213357/article/details/127713676

版权

相同，有限，序列

注：位序从1开始，数组下标从0开始

传入参数的引用“&”——直接对原参数进行修改，反之是对原参数进行复制后修改

1.顺序表

逻辑上相邻，物理位置上也相邻。

顺序表的表长确定后无法更改。

1.1 顺序表的实现

1.1.1 静态分配

#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;    //顺序表初始长度为0
}

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

1.1.2 动态分配

#include <stdlib.h>    //malloc,free函数的头文件
#define InitSize 10    //默认的最大长度

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

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

//增加动态数组的长度
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(){
    SqList L;    //声明一个顺序表
    InitList(L);    //初始化顺序表
    //...往顺序表中随便插入几个元素
    IncreaseSize(L,5);
    return 0;
}

1.1.3 顺序表的特点

随机访问，可以在O（1）时间内找到第i个元素。代码实现为data[i],动态分配和静态分配都一样。
存储密度高，每个节点只存储数据元素。
拓展容量不方便（即使采用动态分配的方式实现，拓展长度的时间复杂度也比较高）。
插入、删除操作不方便，需要移动大量元素。

1.2 顺序表的基本操作

注：本节代码建立在顺序表的“静态分配”实现方式之上，“动态分配”也雷同

1.2.1 插入

时间复杂度：

最好——O（1）

最坏——O（n）

平均——O（n）

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

void ListInsert(SqList &L,int i,int e){    //基本操作：在L的位序i处插入元素e
    if(i<1||i>L.length+1)    //判断i的范围是否有效
        return false;
    if(L.length>=MaxSize)    //当前存储空间已满，不能插入
        return false;
    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
    return true;
}

int main(){
    SqList L;    //声明一个顺序表
    InitList(L);    //初始化顺序表
    //... 此处省略一些代码，插入一些元素
}

1.2.2 删除

时间复杂度同插入

bool ListDelete(SqList &L,int i,int &e){
    if(i<1||i>L.length)    //判断i的范围是否有效
        return false；
    e=L.data[i-1];    //将被删除的元素赋值给e
    for(int j=i;j<L.length;j++)    //将第i个位置的元素前移
        L.data[j-1]=L.data[j]    //从前面的元素依次移动
    L.length--;
    return true;
}

int main(){
    SqList L;    //声明一个顺序表
    InitList(L)    //初始化顺序表
    //... 此处省略，插入几个元素
    int e=-1;    //用变量e把删除的元素“带回来”
    if (ListDelete(L,3,e))
        printf("已删除第3个元素，删除元素值为=%d\n",e);
    else
        printf("位序i不合法，删除失败\n");
    return 0;
}

1.2.3 查找

1.2.3.1 按位查找

时间复杂度：O（1）[随机存取]

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


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

1.2.3.2 按值查找

时间复杂度：同插入

补：C语言中，结构体的比较不能直接用“==”，可以比较结构体内的成员。

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

//在顺序表L中查找第一个元素的值等于e的元素，并返回其位序
int LocateElem(SeqList L,ElemType e){
    for(int i=0;i<L.length;i++)
        if(L.data[i]==e)
            return i+1;    //数组下标为i的元素值等于e，返回其位序i+1
    return 0;    //退出循环，说明查找失败
}