数据结构（顺序表）

顺序表的定义

顺序表：用顺序存储的方式实现线性表顺序存储。把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

顺序表的实现

静态分配

ElemType 指元素类型，可以替换成具体的类型，比如int

#define MaxSize 10

typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;

eg：

#include<stdio.h>

#define MaxSize 10

typedef struct {
	int data[MaxSize];
	int length;
}SeqList;

void InitList(SeqList &L) {
	L.length = 0;
}

int main() {
	SeqList L;
	InitList(L);
	return 0;
}

动态分配

C中动态内存申请和释放

malloc动态申请内存空间，通过malloc函数返回一个指针，即内存空间的首地址
free动态释放内存空间

 L.data = (ElemType *)malloc(sizeof(ElemType) * InitSize);

C++中动态内存申请和释放

new 、delete关键字

#define InitSize 10

typedef struct {
	ElemType * data;
	int MaxSize;
	int length;
}SeqList;

eg：

#include<stdio.h>
#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));
	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;
	free(p);
}

int main() {
	SeqList L;
	InitList(L);
	IncreaseSize(L, 5);
	return 0;
}

顺序表的特点

1.随机访问，即可以在O(1)时间内找到第i个元素。
2.存储密度高，每个节点只存储数据元素。
3.拓展容量不方便（每次拓展需要重新开辟内存空间，将原有数据复制到新的内存空间）

顺序表的基本操作

插入操作

ListInsert(&L,i,e)：插入操作。在表L中的第i个位置插入指定元素e。

#include<stdio.h>

#define MaxSize 10

typedef struct {
	int data[MaxSize];
	int length;
}SeqList;

void InitList(SeqList &L) {
	L.length = 0;
}

// 插入操作
bool ListInsert(SeqList &L, int i, int 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[i] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	return true;
}

int main() {
	SeqList L;
	InitList(L);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 3);
	printf("插入前的值:\n");
	for (int i = 0; i < L.length; i++)
	{
		printf("L.data[%d]=%d\n", i, L.data[i]);
	}
	ListInsert(L, 3, 4);
	printf("插入后的值:\n");
	for (int i = 0; i < L.length; i++)
	{
		printf("L.data[%d]=%d\n", i, L.data[i]);
	}
	return 0;
}

删除操作

#include<stdio.h>

#define MaxSize 10

typedef struct {
	int data[MaxSize];
	int length;
}SeqList;

void InitList(SeqList& L) {
	L.length = 0;
}

bool ListInsert(SeqList &L, int i, int 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[i] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	return true;
}

bool ListDelete(SeqList &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;
}

int main() {
	SeqList L;
	InitList(L);
	ListInsert(L, 1, 1);
	ListInsert(L, 2, 2);
	ListInsert(L, 3, 3);
	printf("插入前的值:\n");
	for (int i = 0; i < L.length; i++)
	{
		printf("L.data[%d]=%d\n", i, L.data[i]);
	}
	ListInsert(L, 3, 4);
	printf("插入后的值:\n");
	for (int i = 0; i < L.length; i++)
	{
		printf("L.data[%d]=%d\n", i, L.data[i]);
	}
	int a;
	ListDelete(L, 1, a);
	printf("删除后的值:\n");
	for (int i = 0; i < L.length; i++)
	{
		printf("L.data[%d]=%d\n", i, L.data[i]);
	}
	return 0;
}

按位查找

GetElem(L, i)：按位查找操作。获取表L中第i个位置的元素的值。
静态分配数据的方式

#define MaxSize 10
typedef struct {
	ElemType data[MaxSize];
	int length;
}SeqList;

ElemType GetElem(SeqList L, int i) {
	return L.data.[i-1];
}

按值查找

LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值得元素。
动态分配数据方式

#define InitSize 10
typedef struct {
	ElemType *data;
	int MaxSize;
	int length;
}SeqList;

int LocateElem(SeqList L, ElemType e) {
	for(int i=0; i<L.length; i++) {
		if(L.data[i] == e)
		return i+1;
	}
	return 0;
}