2-1线性表-顺序表

一.特点
1.优点
（1）随机访问。通过首地址和元素序号可在O(1)内找到指定元素。
（2）存储密度高。每个结点只存储数据元素。
2.缺点
（1）拓展容量不方便
（2）逻辑上相邻的元素物理上也相邻，插入、删除操作需要移动大量元素

二.顺序表的代码定义
（一）静态分配

#define MaxSize 10//最大长度
typedef struct {
	ElemType data[MaxSize];//数组存储各元素
	int length;//当前长度
}SqList;
1
2
3
4
5

（二）动态分配

#define InitSize 10 //初始长度
typedef struct {
	ElemType *data;
	int MaxSize;//数组最大容量
	int length;//当前长度
}SeqList;
1
2
3
4
5
6

三.初始化
（一）静态分配的实现

#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;//初始化每个元素置为0
	L.length = 0;//当前长度为0
}

int main() {
	SqList L;//定义一个顺序表L
	InitList(L);//初始化L
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

（二）动态分配的实现

#include <stdlib.h>
#define InitSize 10
typedef struct {
	int *data;
	int MaxSize;
	int length;
}SeqList;

void InitList(SeqList &L) {
	L.data = (int *)malloc(InitSize*sizeof(int));
	//申请一片连续的内存空间，malloc返回一个指向起始内存地址的指针，强制转化为int，赋给data指针
	L.length = 0;
	L.MaxSize = InitSize;
}

int main() {
	SeqList L;
	InitList(L);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

另：增加动态数组的长度（初始化和定义同上）

void IncreaseSize(SeqList &L, int len) {
	int *p = L.data;//p做为临时指针，指向原位置
	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;//修改长度
	free(p);//释放原来的空间
}

int main() {
	SeqList L;
	InitList(L);
	IncreaseSize(L, 5);//给L加5个长度
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

四.基本操作
（一）插入
1.代码实现

#include <stdio.h>
#define MaxSize 10
typedef struct {//定义
	int data[MaxSize];
	int length;
}SqList;

bool ListInsert(SqList &L, int i, int e) {//插入
	//对L在第i个位置插入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;
}

void InitList(SqList &L) {//初始化
	for (int i = 0; i < MaxSize; i++)
		L.data[i] = 0;
	L.length = 0;
}

int main() {
	SqList L;
	InitList(L);
	if (ListInsert(L, 3, 4))
		printf("成功");
	else
		printf("失败");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

2.时间复杂度
（1）最好：O(1)
（2）最坏：O(n)
（3）平均：O(n)
插在每个位置的概率p=1/(n+1)
因此1×p+2×p+…+n×p=n/2=O(n)
1×p表示移动一次×p
最多移动n次

（二）删除
1.代码实现

bool ListDelete(SqList &L, int i, int &e) {
	//对L删除第i个位置的元素，用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;
}

int main() {
	SqList L;
	InitList(L);
	int e = -1;
	if (ListDelete(L, 3, e))
		printf("成功");
	else
		printf("失败");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2.时间复杂度
（1）最好：O(1)
（2）最坏：n-1=O(n)
（3）平均：O(n)
p=1/n
1×p+2×p+…+(n-1)×p=（n-1）/2=O(n)
最多删（n-1）个

（三）按位查找
1.静态分配

#define MaxSize 10
typedef struct {
	int data[MaxSize];
	int length;
}SqList;
int GetElem(SqList L, int i) {
	//获得表L的第i个元素
	return L.data[i - 1];
}
1
2
3
4
5
6
7
8
9

2.动态分配

#define InitSize 10
typedef struct {
	int *data;
	int MaxSize;
	int length;
}SeqList;
int GetElem(SeqList L, int i) {
	//获得表L的第i个元素
	return L.data[i - 1];
	//L.data[0]表示从起始位置起前4个字节(int)的内存空间，L.data[1]表示5-8内存空间
}
1
2
3
4
5
6
7
8
9
10
11

3.时间复杂度：O（1）

（四）按值查找
1.代码实现

int LocateElem(SqList L, int e) {//动态分配将SqList改为SeqList即可
	//在表L中查找值为e的元素
	for (int i = 0; i < L.length; i++) 
		if (L.data[i] == e)//两个结构类型不能用“==”比较
			return i + 1;
	return 0;//for循环结束仍未找到，失败
}
1
2
3
4
5
6
7

2.时间复杂度
（1）最好：O(1)
（2）最坏：O(n)
（3）平均：O(n)
p=1/n
1×p+2×p+…+n×p=(n+1)/2=O(n)