数据结构线性表部分

章节目录

一、线性表定义

二、线性表顺序存储

顺序表的定义：

数组静态分配 ：

数组动态分配：

动态分配语句（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<L.length；j++）
		L.data[j-1]=L.data[j]；
	return true；
}

最好时间复杂度：O（1）

平均时间复杂度：O（n）

最坏时间复杂度：O（n）

顺序表的按值查找：

int LocateElem（SqList L，ElemType e）{
	int i；
	for（i=0；i<L.length；i++）{
		if（L.data[i]==e）
			return i+1；
	}
	return 0；
}

最好时间复杂度：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&&j<i）{  //按序号查找
		p=p->next；
		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