顺序表的C语言实现(静态/动态)_c语言动态实现顺序表-CSDN博客

本文链接：https://blog.csdn.net/Paradox_33/article/details/133139000

一、顺序表的定义

1.静态实现

#include<stdio.h>
//
// Created by Paradox on 2023/9/21.
//
#define MAXSIZE 10              //定义最大长度
typedef struct{
    Elemtype data[MAXSIZE];     //静态数组存储数据元素
    int length;                 //表当前的长度;
}Sqlist;                        //类型定义(名字)

void InitList (Sqlist *L){      //初始化一个顺序表
    for(int i=0;i<MAXSIZE;i++)
        L->data[i]=0;            //设置初始值(可省略);如果不设置初始值为0的话,若访问则可能访问的到遗留脏数据
    return 0;
}

2.动态实现

#include<stdio.h>
#include<stdlib.h>             //用于存储free,malloc等函数的头文件
#define INITSIZE 10            //初始最大长度
typedef struct{
    Elemtype *data;            //这里Elemtype是顺序表中元素的数据类型
    int Maxsize;               //顺序表最大容量
    int length;                //当前长度
}Seqlist;

void Initlist(Seqlist *L){
    
    L->data=(Elemtype*)malloc(INITSIZE*sizeof(Elemtype)); 
    //这里的Elemtype只是个占位符;如果你想建立一个整型的顺序表,应将Elemtype改为int
    //给L->data指针(数组)指向了heap中的INITSIZE个Elemtype类型的大小的存储空间
    
    L->length=0;                //因为还没输入数据,所以定义为零;
    
    L->Maxsize=INITSIZE;        
    /* 之所以我们不仅仅是像静态分配一样,给定一个字符常量作为最大值,就是为了之后能通过对L.Maxsize的改变,分配更大的存储空间. */
}

void Increase(Seqlist *L,int len){
    Elemtype *p=L->data;        //先建立指针p指向在heap中分配的10个Elemtype类型大小的存储空间
    L->data=(Elemtype*)malloc((L->Maxsize+len)*sizeof(Elemtype));
    //给动态数组分配更大的存储空间
    for(int i=0;i<L->length;i++){
        L->data[i]=p[i];        //将存储在之前存储空间的数据都赋值给新的存储空间
    }
    L->MaxSize=L->Maxsize+len;  //更新存储大小
    free(p);                    //释放p指针指向的动态存储空间(曾经的内存空间)的值.
}

需要注意的是,王道考研所给出的代码,在将结构体作为实际参数传参的时候,使用的是&引用传参,实际上这只能在C++中实现.

在C中,我们用地址传递,即传递结构体指针.

	地址传递	引用传参
函数声明	void Initlist(*Seqlist L**);	void Initlist(Seqlist &L);
在函数中访问结构体成员	L->length	L.length
在主调函数中调用地址	Initlist(&L1);	Initlist(L1)

3.顺序表的特点

①随机访问，即可以在O(1)时间内(常数级时间复杂度)找到第1个元素。
②存储密度高,每个节点只存储数据元素。
③拓展容量不方便(即便采用动态分配的方式实现,拓展长度的时间复杂度也比较高)。
④插入、删除数据元素不方便。

二、线性表的基本操作

先定义一个静态分配的线性表：

#define MAXSIZE 10
typedef struct{
    Elemtype data[MAXSIZE];
    int length;
}Sqlist;

1.ListInsert 插入操作

//插入这个操作需要引用三个参数:顺序表的首地址L,插入位置i(逻辑上第i个,数组中的第i-1个),插入数据e
//当然在C++中,可以直接引用调用L
void ListInsert(Sqlist *L,int i,int e){    
    for(int j=L->length;j=i;j--) 
        L->data[j]=L->data[j-1];    //将数据从左侧元素往右侧元素赋值
    L->data[i-1]=e;                 //给data[i-1]赋值e
    L->length++;                    //更新表长
}

int main(){
    Sqlist L;              //声明一个顺序表
    InitList(&L);           //初始化顺序表
/*
    省略一些存入几个数据的代码
                               */
    ListInsert(&L,3,3);    //在数组的第三位插入值为3的整形数据,将结构体的指针传给函数
    return 0;
}

这里for循环的条件是:
for(int j=i;j=L->length;j--)
这里是从右往左遍历数组元素——一般在插入操作时,都是将指针从右往左遍历.
至于为什么要在[i-1]之后的位置让指针(也可以说是数组下标)从右向左遍历,你可以想象是在一条停满了车的路上硬塞入一辆车.我们必须让最右边的一辆车往右边腾出空间,一个一个往右让,才能给你在想要的地方腾出一个空间.

但是我们在设计数据结构的时候,必须要让自己实现的数据结构放心且方便的让别人使用.即我们说的,让代码具有"鲁棒性"
于是我们需要考察我们构建的函数,加入一些"人性化"的部分.

[改进] 在函数的开头加入一个判断输入有效性的部分.

        1.将void类型(不返回值)的函数改为了bool类型(返回true或false——切记不可以使用0或非0整数替代true或false)的函数.
        2.在函数中加入了两个if语句来判断数据结构的访问或存储是否出现问题:
        ①是否访问了表长范围之外的元素(我们可以在第1位(首位)或者第length+1位(最后一位的后一位)插入数据元素.)
        ②是否出现了数据溢出的情况(表长已经大于我们给顺序表分配的内存空间的大小)
如果出现以上情况,则直接返回false.
        如果没问题,在执行函数的主要部分并返回true.

bool ListInsert(Sqlist *L,int i,int e){
    if(i<1||i>L->length+1)
        return false;
    if(L->length>=Maxsize)
        return false;
    for(int j=L->length;j=i;j--) 
        L->data[j]=L->data[j-1];    //将数据从左侧元素往右侧元素赋值
    L->data[i-1]=e;                 //给data[i-1]赋值e
    L->length++;                    //更新表长
    return true;
}

判断插入操作的时间复杂度

最好情况: 新元素插入到表尾,不需要移动元素
即 i=n+1,循环0次,此时最好时间复杂度=O(1)
最坏情况: 新元素插入到表头,需要移动n元素
即 i=n+1,循环0次,此时最好时间复杂度=O(1)
平均情况: 假设新元素插入到任何位置的概率相同, 则插入到1到length+1的位置的概率都是1/n+1,则平均的i=1,循环n次;i=2循环n-1次...则f(n)=(n(n+1)/2)*(1/1+n)=n/2
则平均时间复杂度=O(n)

2.顺序表的基本操作——删除

需要注意的点是,我们增加了一个指针型变量,负责将被删除的数据元素中存储的值赋给该变量,带出函数.

bool ListDelete（Sqlist *L,int i,int *e)
{
    if(i<1||i>L->length)            //判断有效性
        return false;
    e=L->data[i-1];                 //将被删除元素通过指针型变量带出函数
    for(j=i;j<length;j++)
        L->data[j-1]=L->data[j];    //将i-1右边的数据元素往左移一位
    L->length--;                    //更新顺序表长度
    return true;                    //返回true
}

判断插入操作的时间复杂度

最好情况: 删除表尾元素,不需要移动其他元素
即 i=n,循环0次,此时最好时间复杂度=O(1)
最坏情况: 删除表头元素,需要移动n-1个元素
即 i=1,循环n-1次,此时最坏时间复杂度=O(n)
平均情况: 假设新元素插入到任何位置的概率相同, 则插入到1到length的位置的概率都是1/n,则平均的i=1,循环n次;i=2循环n-1次...则f(n)=(n(n-1)/2)*(1/n)=(n-1)/2
则平均时间复杂度=O(n)

3.顺序表的基本操作——查找

3.1 按位查找

按位查找,输入数据结构和元素所在位置,输出元素中存储的值.

静态分配

#define MAXSIZE 10
typedef struct{
    Elemtype data[MAXSIZE];
    int length;
}Sqlist;

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

动态分配

#include<stdio.h>
#include<stdlib.h>             //用于存储free,malloc等函数的头文件
#define INITSIZE 10            //初始最大长度
typedef struct{
    Elemtype *data;            //这里Elemtype是顺序表中元素的数据类型
    int Maxsize;               //顺序表最大容量
    int length;                //当前长度
}Seqlist;

void main(){
    int a;
    Seqlist L1;
    Initlist(&L);
    a=GetElem(L,3);
}

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

void Initlist(Seqlist *L){
    L->data=(Elemtype*)malloc(INITSIZE*sizeof(Elemtype));     
    L->length=0;                   
    L->Maxsize=INITSIZE;        
}

无论是动态还是静态的内存分配方式,按位查找的时间复杂度都是O(1).因为顺序表在内存中连续存放,所以根据起始地址和数据元素大小可以立即找到第i个元素.

3.2 按值查找

按值查找,即根据输入的数据结构和某个值,返回对应的数据元素的位序.

int LocateElem(strcut Seqlist L,Elemtype e){
    for(int i=0;i<L.length;i++) //从0到length-1遍历顺序表
        if(L.data[i]==e)
            return i+1;   //返回的是位序,下标+1
        return 0;         //若返回0,则代表顺序表中不存在此元素
}

[探讨]结构类型的比较

如果这个顺序表中存储的数据类型不是基本数据类型,而是结构体的话,是否能够通过"=="这个比较运算符来比较两个结构类型呢?答案是否定的.
假设我们比较的是结构体a和结构体b，如果我们直接用a==b是不成立的.

typedef struct{
    int num;
    int people;
}Customer;

void test(){
    Customer a={1,1},b={1,1};    //结构体使用{,}这种方式初始化,只有在定义的时候才可以
    if(a==b){            //这里的比较是错误的,这个二元运算符不能实现对两个Customer类型的比较
        printf("相等");
    }
    else printf("不相等")
}

实际上,我们可以定义一个函数来比较两个结构体(中存储的元素)是否相同:

bool isCustomerEqual (Customer a,Customer b){
    if(a.num==b.num && a.people == b.people)
        return true;
    else
        return false;
}

之后,我们将if(a==b)改为if(isCustomerEqual(a,b)).便可以实现对结构体进行比较的效果.