【数据结构学习笔记】2.2线性表的顺序表示
1.线性表存储类型描述---静态分配
#define MaxSize 10 //定义最大长度
typedef struct{
ElemType data[MaxSize]; //用静态的"数组"存放数据元素
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义(静态分配方式)
【Key】ElemType 依据代码的实际情况去修改。
2.示例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;
}
【Alarm】此处第一步是给元素在内存中分配存储空间MaxSzie*sizeof(ElemType)和存储length的空间。
4.示例2---不初始化数据元素，内存不刷0---静态分配
#include <stdio.h>
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的"数组"存放数据元素
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义
// 基本操作---初始化一个顺序表
void InitList(SqList &L){ //没有设置元素的默认值
L.length=0; //顺序表初始长度为0
}
int main(){
SqList L; //声明一个顺序表
InitList(L); //初始化顺序表
// 尝试"违规"打印整个 data 数组
for(int i=0;i<MaxSize;i++)
printf("data[%d]=%d\n",i,L.data[i]);
return 0;
}
output：
data[0]=1
data[1]=0
data[2]=4203657
data[3]=0
data[4]=0
data[5]=0
data[6]=53
data[7]=0
data[8]=0
data[9]=0
//其中data[0]、data[2]、data[6]不等于0，是由于内存中存在"脏数据"
【Key】初始化顺序表的时候一定要声明length=0
5.线性表存储类型描述---动态分配
#define InitSize 10 //顺序表的初始长度
typedef struct{
ElemType *data; //指示动态分配数组的指针
int MaxSize; //顺序表的最大容量
int length; //顺序表的当前长度
}SeqList; //顺序表的类型定义(动态分配方式)
-
【Key】动态申请和释放内存空间
-
C---malloc、free
L.data=(ElemType *) malloc(sizeof(ElemType)*InitSize);(ElemType *) : malloc函数返回一个指针，需要强制转型为你定义的数据元素类型指针
(sizeof(ElemType)*InitSize) : malloc函数的参数，指明要分配多大的连续内存空间
-
C++---new、delete关键字
-
6.示例１---扩展顺序表--动态分配
#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(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(){
SeqList L; //声明一个顺序表
InitList(L); //初始化顺序表
//…往顺序表中随便插入几个元素…
IncreaseSize(L,5);
return 0;
}
7.顺序表的基本操作---插入
#define MaxSize 10 //定义最大长度
typedef struct{
int data[MaxSize]; //用静态的"数组"存放数据元素
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义
//基本操作：在L的位序i处插入元素e
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);
return 0;
}
但是以上代码在健壮性上存在一些问题，所以需要优化一下。以下是优化之后的插入算法。“健壮性”up！
bool ListInsert(SqList &L,int i,int e){
if(i<i||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;
}
以上代码的时间复杂度分析：
我们在分析代码的时间复杂度时，需要关注最深层循环语句的执行次数与问题规模n的关系。
-
最好情况：新元素插入到表尾，不需要移动元素
i=n+1，循环0次；最好时间复杂度=O(1)
-
最坏情况：新元素插入到表头，需要将原有的n个元素全都向后移动
i=1，循环n次，最坏时间复杂度=O(n)
-
平均情况：假设新元素插入到任何一个位置的概率相同，为1/(n+1)
i=1,循环n次；……i=n+1,循环0次
平均循环次数=[n(n+1)/2]*[1/(n+1)]=n/2
平均时间复杂度=O(n)
8.顺序表的基本操作---删除
bool ListDelete(SqList &L,int i,int &e){
if(i<1||i>L.length)
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;
}
以上代码的时间复杂度分析：
我们在分析代码的时间复杂度时，需要关注最深层循环语句的执行次数与问题规模n的关系。
-
最好情况：新元素插入到表尾，不需要移动元素
i=n，循环0次；最好时间复杂度=O(1)
-
最坏情况：新元素插入到表头，需要将原有的n个元素全都向后移动
i=1，循环n-1次，最坏时间复杂度=O(n)
-
平均情况：假设新元素插入到任何一个位置的概率相同，为1/n
i=1,循环n-1次；……i=n+1,循环0次
平均循环次数=[n(n-1)/2]*[1/n]=(n-1)/2
平均时间复杂度=O(n)
9.顺序表的按位查找
GetElem(L,i):按位查找操作。获取表L中第i个位置的元素值。
静态分配
typedef struct{
ElemType data[MaxSize]; //用静态的"数组"存放数据元素(静态分配)
int length; //顺序表的当前长度
}SqList; //顺序表的类型定义(静态分配方式)
ElemType GetElem(SqList L,int i){
return L.data[i-1];
}
动态分配
#define InitSize 10
typedef struct{
ElemType *data; //指示动态分配数组的指针(动态分配)
int MaxSize;
int length;
}SeqList; //顺序表的类型定义(动态分配方式)
ElemType GetElem(SeqList L,int i){
return L.data[i-1];
}
GetElem(L,i)的时复杂度：O(1)
由于顺序表的各个数据元素在内存中连续存放，因此可以根据起始地址和数据元素大小立即找到第i个元素---"随机存取"特性
10.顺序表的按值查找
LocateElem(L,e):按值查找操作。在表L中查找据具有给定关键字值的元素。
#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;
}
return 0; //退出循环，说明查找失败
}
LocateElem(L,e):时间复杂度
最好时间复杂度：O(1)
最坏时间复杂度：O(n)
平均时间复杂度：O(n)
11.结构类型的比较
【Key】C语言中。结构体的比较不能直接用"=="，需要依次对比各个分量来判断两个结构体是否相等
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==b){
printf("相等");
}else{
printf("不相等");
}
/*正确比较写法*/
if(a.num==b.num&&a.people==b.people){
printf("相等");
} else{
printf("不相等");
}
}
//另一种正确的比较方式
bool is CustomerEqual(Customer a,Customer b){
if(a.num==b.num&&a.people==b.people)
return true;
else
return false;
}
\
