数据结构--线性表--顺序表

静态数组下顺序表的操作

# include <stdio.h> 
# include <stdlib.h>

#define MaxSize 10

typedef struct {
	int data[MaxSize]; //用静态数组存放数据元素
	int length;         //顺序表当前的长度
}SqList;               //顺序表的类型定义
//初始化顺序表。令数组中的元素值都等于0，防止遗留脏数据，长度也是0；
void InitList(SqList& L) {   
	for (int i = 0; i < MaxSize; i++)
		L.data[i] = 0;
	L.length = 0;
}
/*
顺序表的插入操作。
1.需要返回插入后的表，所以SqList& L。在位置i插入元素e；
2.需要将i位置之后的元素后移；
3.最后插入成功长度不要忘记+1；
*/
bool ListInsert(SqList& L, int i, int e) {
	/*
	为了增强健壮性，增加判断i的范围是否有效，和空间已满不能插入
	*/
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length >= 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;
}
/*
顺序表的删除操作。
1.需要返回删除后的表和删除的数据。所以SqList& L；int& e；
2.物理位置i是从1 开始的，而数组下标是从0 开始的，注意对应！！
4.需要将i位置之后的元素前移；
3.删除后不要忘记长度-1；
*/
bool ListDelete(SqList& L, int i, int& e) {
	if (i<1 || i>L.length)  //判断i的范围是否有效
		return false;
	e = L.data[i - 1];   //将被删除的元素赋给e
	for (int j = i; j < L.length; j++)//将第i个位置以后的元素前移
		L.data[j - 1] = L.data[j];
	L.length--;//线性表长度减一
	return true;
}
/*
顺序表按位查找。
1.注意物理位置和逻辑位置！！
2.返回查找的值int &e
*/
bool GetElem(SqList L, int i ,int &e) {
	if (i<1 || i>L.length)
		return false;
	e = L.data[i - 1];//传入的i是数据元素的位序，在数组中表示差1.
	return true;
}

/*
顺序表按值查找。
1.从头开始找，如果i的范围合法，对应的值不是要找的，继续找下一个
2.最后返回物理位置，不要忘记+1；
*/

int LocateElem(SqList L, int e) {
	int i = 0;
	while (i < L.length && L.data[i - 1] != e)
		i++;
	if (i >= L.length)
		return 0;
	else
		return i + 1;
}

int main() {
	SqList L;
	InitList(L);

	int e = 1;//用变量e把删除的元素“带回来”
	if (ListDelete(L, 2, e))
		printf("已删除第2个元素，删除的元素值为%d\n", e);
	else
		printf("序位i不合法，删除失败\n");

	ListInsert(L, 5, 2);

	int ee = 0;
	GetElem(L, 2, ee);

	int i = LocateElem(L, 5);
	return 0;

}

动态数组下顺序表的操作

#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));//用malloc函数申请一片连续的空间
	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;   //线性表的最大长度加len
	free(p);   //释放原来的内存空间
}

bool ListInsert(SeqList& L, int i, int e) {
	/*
	为了增强健壮性，增加判断i的范围是否有效，和空间已满不能插入
	*/
	if (i<1 || i>L.length + 1)
		return false;
	if (L.length >= L.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;
}
bool ListDelete(SeqList& L, int i, int& e) {
	if (i<1 || i>L.length)  //判断i的范围是否有效
		return false;
	e = L.data[i - 1];   //将被删除的元素赋给e
	for (int j = i; j < L.length; j++)//将第i个位置以后的元素前移
		L.data[j - 1] = L.data[j];
	L.length--;//线性表长度减一
	return true;
}
bool GetElem(SeqList L, int i, int& e) {
	if (i<1 || i>L.length)
		return false;
	e = L.data[i - 1];//传入的i是数据元素的位序，在数组中表示差1.
	return true;
}
int LocateElem(SeqList L, int e) {
	int i = 0;
	while (i < L.length && L.data[i - 1] != e)
		i++;
	if (i >= L.length)
		return 0;
	else
		return i + 1;
}
int main() {
	SeqList L;
	InitList(L);
	return 0;
}