数据结构线性表部分
章节目录
一、线性表定义
二、线性表顺序存储
顺序表的定义：
数组静态分配 ：
数组动态分配：
动态分配语句（C++）：
顺序表的插入操作：
顺序表的删除操作：
顺序表的按值查找：
三、线性表链式存储
头插法建立：
尾插法建立：
增删改查求表长代码：
双向链表：
双向链表的插入与删除：
四、方式比较
一、线性表定义
线性表的定义：线性表是具有相同类型的n个元素的有限序列，其中n为表长，当n=0时，该表为空。
若L命名为线性表，则一般表示为L=（a1,a2,a3,...,ai,ai+1,...,an）
线性表的特点：有限，先后次序，有数据元素，数据类型都相同，具有抽象性，是一种逻辑结构。
线性表的九种基本操作：
1、InitList（&L）：初始化表。构建一个空的线性表。
2、DestroyList（&L）：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。
3、LocateElem（L，e）：按值查找操作，在表L中查找具有关键字值的元素。
4、GetElem（L，i）：按位查找操作。
5、ListInsert（&L，i，e）插入操作。在L的第i个位置插入e。
6、ListDelete（&L，i，&e）删除操作。把L的第i个位置删掉，并返回值e。
7、PrintList（L）：输出操作。
8、Empty（L）：判空操作。
9、Length（L）：求表长。
二、线性表顺序存储
顺序表的定义：
线性表的顺序存储又称顺序表
一组地址连续存放的存储单元依次存放线性表的元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。
L=（a1,a2,a3,...,ai,ai+1,...,an）
数组静态分配 ：
# define MaxSize=50
typedef struct{
ElemType data[MaxSize]；
int length.
}SqList;
数组动态分配：
# define MaxSize=50
typedef struct{
ElemType *data；
int length.
}SqList;
动态分配语句（C++）：
L.data = new ElemType[InitSize];顺序表的插入操作：
bool ListInsert（SqList &L，int i，ElemType 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；
L.length++；
return true；
}
最好时间复杂度：O（1），i正好是末尾
平均时间复杂度：O（n）
最坏时间复杂度：O（n）
顺序表的删除操作：
bool ListDelete（SqList &L，int i，ElemType &e）{
if（i<1 || i>L.length+1）
return false；
e=L.data[i-1];
for（int j=i；j最好时间复杂度：O（1）
平均时间复杂度：O（n）
最坏时间复杂度：O（n）
顺序表的按值查找：
int LocateElem（SqList L，ElemType e）{
int i；
for（i=0；i最好时间复杂度：O（1）
平均时间复杂度：O（n）
最坏时间复杂度：O（n）
三、线性表链式存储
//结点定义代码：
typedef struct LNode{
ElemType data ；
struct LNode *next；
}LNode，*LinkList；
头插法建立：
s->next=L->next；
L->next=s；
LinkList List_HeadInsert（LinkList &L）{
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=Null;
scanf(“%d”,&x);
while(x!=9999){
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
scanf(“%d”,&x);
}
return L;
}
最坏时间复杂度：O（n）
尾插法建立：
LinkList List_TailInsert(LinkList &L){
int x;
L=(LinkList)malloc(sizeof(LNode));
LNode *s,*r=L;
scanf(“%d”,&x);
while(x!=9999){
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
r->next=s;
r=s;
scanf(“%d”,&x);
}
return L;
}
最坏时间复杂度：O（n）
增删改查求表长代码：
int main(){
while（p&&jnext；
j++；
}
while（p！=NUll&&p->data！=e）{ //按值查找
p=p->next；
}
return p；
p=GetElem（L,i-1）；//插入节点（前插法）
s->next=p->next；
p->next=s；
//（后插法，确定i的位置，时间复杂度：O（n））
p=GetElem(L,i-1)； //删除节点
q=p->next；
p->next=q->next；
free（q）； //时间复杂度同插入
int count=0； //求表长
p=head；
while（p->next！=NULL）{
count++；
p=p->next； // 时间复杂度：O（n）
}
} 双向链表：
双链表结点：
双向链表的插入与删除：
s->next=p->next； // 插入
p->next->prior=s；
s->prior=p；
p->next=s； // 时间复杂度：O(1)
p->next=q->next； // 删除
q->next->prior=p；
free（q）； // 时间复杂度：O（1）
四、方式比较
如果能解决您的问题，记得收藏+关注呀！！！
创作时间：2022.2.14
文章编号YU.NO.4