数据结构线性表——顺序表代码

1.1 静态分配

#include<stdio.h>

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

//基本操作——初始化一个顺序表
void InitList(SqList &L){
    L.length=0;			//顺序表初始长度为0
}

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

1.2 动态分配

#include<stdlib.h>		//malloc、free函数的头文件
#define InitSize 10		//顺序表的初始长度
typedef struct{
    int *data;		//指示动态分配数组的指针
    int MaxSize;		//顺序表的最大容量
    int length;			//顺序表的当前长度
} SeqList;				//顺序表的类型定义（动态分配方式）

void InitList(SeqList &L){
    //用malloc函数申请一片连续的存储空间
    L.data=(int *)malloc(sizeof(int)*InitSize);
    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(){
    SeqList L;		//声明一个顺序表
    InitList(L);	//初始化顺序表
    //...此处省略部分代码，往顺序表里插入几个元素
    IncreaseSize(L,5);
    return 0;
}

1.3 插入——O(n)

ListInsert(&L,i,e):插入操作。在表L中的第i个位置上插入指定元素e。

#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(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);		//初始化顺序表
    //...此处省略部分代码，插入几个元素
    ListInsert(L,3,3);	//此处的3是指位序，实际上是指数组中下标为2的位置
    return 0;
}

1.4 删除——O(n)

bool ListDelete(SqList &L,int i,int &e){	//i表示位序，e是引用型变量，如果&L不加&,则是复制一个顺序表
    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--;					//线性表长度减1
    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.5 查找

1.5.1 按位查找——O(1)

GetElem(L,i):按位查找操作。获取表L中第i个位置的元素的值。

1.5.1.1 静态分配

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

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

1.5.1.2 动态分配

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

int GetElem(SeqList L,int i){
    return L.data[i-1];			//指针每次所取的字节大小，与指针的类型有关
}

1.5.2 按值查找——O(n)

LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值的元素。

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

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

1.6 结构类型的比较

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

void test(){
    Customer a;
    a.num=1;
    a.people=1;
    Customer b;
    b.num=1;
    b.people=1;
    if(a.num==b.num&&a.people==b.people){//直接写a==b，会报错
        printf("相等");
    }else{
        printf("不相等")
    }
}