线性表
1.定义
线性表是具有相同(每个数据元素所占空间一样大)数据类型的n(n≥0)个数据元素的有限序列,其中n为表长,当n=0时线性表是一个空表。若用L命名线性表,则其一般表示为
L=(a1,a2,…,aj,aj+1,…,an)
几个概念:
ai是线性表中的“第i个”元素线性表中的位序
a1是表头元素:an是表尾元素。
除第一个元素外,每个元素有且仅有一个直接前驱:除最后一个元素外,每个元素有且仅有一个直接后继
2.线性表基本操作
InitList(&L)
:初始化表,构造一个空的线性表L,构造一个空的线性表,分配内存空间。
DestoryList(&L)
:销毁操作。销毁线性表,并释放线性表L所占用的内存空间。
ListInser(&L,i,e)
:插入操作,在表L中的第i个位置上插入指定元素e。
ListDelete(&L,&e)
:删除操作。删除表L中第i个位置的元素,并用e返回删除元素的值。
LocateElem(L,e)
:按值查找操作。在表L中查找具有给定关键字值的元素。
GetElem(L,i)
:按位查找操作,获取表L中第i个位置的元素的值。
其他常用操作:
Length(L)
:求表长,返回线性表L的长度,即L中数据元素的个数。
PrintList(L)
:输出操作。按前后顺序输出线性表L的所有元素值。
Empty(L)
:判空操作。若L为空表,则返回true,否则返回false。
Tips:
①对数据的操作(记忆思路)————创销、增删改查
②C语言函数的定义 ———— <返回值类型>函数名{<参数1类型>参数1,<参数2类型>参数2,…}
③实际开发中,可根据实际需求定义其他的基本操作
④函数名和参数的形式、命名都可改变(Reference:严蔚敏版《数据结构》)
⑤什么时候要传入引用"&" ——对参数的修改结果需要“带回来”
顺序表
顺序表的定义
**顺序表——用顺序存储的方式实现线性表顺序存储。**把逻辑上相邻的元素存储在物理位置上也相邻的储单元中,元素之间的关系由存储单元的相邻关系来体现。
如何河道一个数据元素的的大小?
C语言sizeof(ElemType)
顺序表的实现——静态分配
#define MaxSize 10 // 定义最大长度
typedef struct{
ElemType data(MaxSize); // 用静态的“数组”存放数据元素
int length; // 顺序表的当前长度
}SqList // 顺序表的类型定义(静态分配方式) Sq(sequence--顺序、序列)
大小确定之后不可改变
Q:如果“数组”存满了怎么办?
A:可以放弃治疗,顺序表的表长刚开始确定后就无法更改(存储空间是静态的)
顺序表的实现——动态分配
#define InitSize 10 // 顺序表的初始长度
typedef struct{
ElemType *data; // 指示动态分配数组的指针
int MaxSize; // 顺序表的最大容量
int length; // 顺序表的当前长度
} SeqList; // 顺序表的类型定义(动态分配方式)
Key:动态申请和释放内存空间
C —— malloc、free 函数
L.data = (ElemType *)malloc(sizeof(ElemType)*InitSie);
Tips:malloc
函数返回一个指针,需要请回转型为你定义的数据元素类型指针
代码示例
#include <studlib.h>
#define InitSize 10 // 默认的最大长度
typeof 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;
}
int main() {
SeqList L; // 声明一个顺序表
InitList(L); // 初始化顺序表
// ...往顺序表中随便插入几个元素...
IncreaseSize(L,5);
return 0;
}
void IncreaseSize(SeqList &L,int len) {
int *p=L.data;
L.data=(int *)malloc((L.MaxSize+len)*sieof*(int));
for(int i=0;i<length;i++){
L.data[i]=p[i]; // 将数据复制到新区域
}
L.MaxSize=L.MaxSize+len; // 顺序表最大长度增加 len
free(p) // 释放原来的内存空间
}
顺序表的特点
- 随机访问,即可以在O(1)时间内找到第i个元素。
- 存储密度高,每个节点组织存储数据元素
- 拓展容量不方便(即便采用动态分配的方式实现,拓展长度的时间复杂度也比较高)
- 插入、删除操作不方便,需要移动大量元素
顺序表的基本操作——插入
Listinsert(&L,i,e)
:插入操作,在表L中的第i个位置插入指定元素e。
插入操作的时间复杂度
bool ListInsert(SqList &L,int i ,int e){
if(i<1||i>L.length+1) // 判断i的范围是否有效
return false;
if(L.ength>=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;
}
最好情况:新元素插入到表尾,不需要移动元素 i=n+1
,循环0次,最好时间复杂度
=O(1)
最坏情况:新元素插入到表头,需要将原有的n个元素全都向后移动i=1
,循环n次,最坏时间复杂度
=O(n);
平均情况:假设元素插入到任何一个位置的概率相同,即i=1,2,3,···length+1
的概率都是p=1/n+1
i=1,循环n次;i=2时,循环n-1次;i=3,循环n-2次 … i=n+1时,循环0次,平均时间复杂度
=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(int j=i;j<L.length;j++)
L.data[j-1]=L.data[j];
L.length--;
return true;
}
删除的时间复杂度
最好情况:删除表尾元素,不需要移动其他元素 i=n,循环0次;最好时间复杂度
=O(1)
最坏情况:删除表头元素,需要将后续的n-1个元素全都向前移动 i=1,循环n-1次;最坏时间复杂度
=O(n);
平均情况:假设删除任何一个元素的概率相同,即i=1,2,3,…,length的概率都是p=1/n i=1,循环n-1次;i=2时,循环n-2次;i=3,循环n-3次 …i=n时,循环0次 平均时间复杂度
=O(n)
顺序表的基本操作——查找
1.按位查找
GetElem(L,i):按位查找
操作。获取表L中第i个位置的元素的值。
代码示例:
- 静态
#define MaxSize 10 // 定义最大长度
typedef strucr{
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; // 顺序表的类型定义(动态分配方式)
按位查找的时间复杂度
时间复杂度为O(1)
注:
- 一个int占4B
- 一个ElemType占2000B
2.按值查找
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; // 数组下标为i的元素值等于e,返回其位序i+1
return 0; // 退出循环,说明查找失败
}
按值查找的时间复杂度
最好情况: 元素在表头,最好时间复杂度=O(1)
最坏情况: 元素在表尾,最坏时间复杂度=O(n)
平均情况:平均时间复杂度=O(n)