数据结构代码实现——顺序表定义、插入、删除、查找_顺序表的删除操作代码

1.顺序表定义（静态分配）

基本操作

        InitList(&L)：初始化表。构造一个空的线性表。

        用静态数组定义顺序表。由于数组的大小和空间已固定，一旦空间占满，再加入新的数据就会产生溢出。

// 顺序表定义——静态分配 
#include <stdio.h> 
 
#define MaxSize 10 // 定义最大长度
 
typedef struct {
	int data[MaxSize]; // 数组存储线性表
	int length; // 定义表长 
}SqList;
 
// 初始化，初始值为0
void InitList(SqList *L) {
	int i;
	for(i=0; i<MaxSize; i++) {
		L->data[i] = 0;
	}
	L->length = 0;
} 
 
int main() {
	SqList L;
	InitList(&L);
	int i;
	for(i=0; i<MaxSize; i++) {
		printf("%d,",L.data[i]); 
	}
	return 0;
}

补充：

1、C语言关于结构体做参数传递：

https://blog.csdn.net/lin37985/article/details/38582027

若想在函数内改变结构体的值，需要给函数传递结构体的地址

用&L做实参，&L是结构体变量L的地址。在调用函数时将该地址传送给形参L(L是指针变量)。这样L就指向实参。

2、值传递与地址传递

        值传递：这种方式使用变量、常量、数组元素作为函数参数，实际是将实参的值复制到形参相应的存储单元中，即形参和实参分别占用不同的存储单元。

        地址传递：这种方式使用数组名或者指针作为函数参数，传递的是该数组的首地址或指针的值，而形参接收到的是地址，即指向实参的存储单元，形参和实参占用相同的存储单元，这种传递方式称为“参数的地址传递”。

准确定义：

        int *p;        p =  &x;        或

        int *p = &x;

        *p代表x地址处具体存放的数据；p代表x的地址值；&x代表x的地址值；x代表x地址处具体存放的数据。

3、结构体.与->的区别

看调用者的类型，如果调用者是指针，就在它后边用 ->；如果它不是地址，就在它后边就用 .

2.顺序表定义（动态分配）

基本操作

        InitList(&L)：初始化表。构造一个空的线性表。

        采用动态分配内存的方式定义顺序表。

        存储数组的空间是在程序执行过程中通过动态存储分配语句分配的，一旦数据空间占满，就另外开辟一块更大的存储空间，用来替换原来的存储空间，从而达到扩充存储数组空间的目的。原来的数据整体复制到新数组内。

// 顺序表定义——动态分配
#include<stdio.h>
#include<malloc.h>
 
#define InitSize 10 // 定义初始长度
 
typedef struct {
	int *data; //数据头指针
	int MaxSize; //数据最大容量
	int length; //数组长度 
}SqList;
 
void InitList(SqList *L) {
	L->data = (int*)malloc(InitSize * sizeof(int)); // 动态分配内存 
	L->MaxSize = InitSize;
	int i;
	for(i=0; i<L->MaxSize; i++) 
		L->data[i] = 0; // 设置默认值
	L->length = 0; 
} 
 
void IncreaseSize(SqList *L) {
	int *p = L->data;
	L->data = (int*)malloc((L->MaxSize+InitSize)*sizeof(int));
	int i;
	for(i=0; i<L->length; i++) {
		L->data[i] = p[i]; 
	}
	L->MaxSize = L->MaxSize + InitSize;
	for(i=L->length; i<L->MaxSize; i++) {
		L->data[i] = 0;
	}
	free(p);
}
 
int main() {
	SqList L;
	InitList(&L); // 初始化数组 
	// 赋值0-9
	int i;
	for(i=0; i<L.MaxSize; i++) {
		L.data[i] = i;
		L.length++;
	} 
	for(i=0; i<L.MaxSize; i++) {
		printf("%d,", L.data[i]);
	}
	printf("\n");
	if(L.length == L.MaxSize)
		IncreaseSize(&L);
	for(i=0; i<L.MaxSize; i++) {
		printf("%d,", L.data[i]);
	}
	return 0;
}

 3.顺序表插入

基本操作：

        ListInsert(&L, i ,e)：在顺序表的第i个位置插入e 

 
//插入元素 ListInsert(&L, i ,e)
 
#include<stdio.h>
#include <stdbool.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;
}
 
bool ListInsert(SqList *L, int i, int e) { //在第i个位置插入e 
	if(L->length >= MaxSize) { //合法性验证 
		printf("顺序表已满"); 
		return false;
	}
	if(i<1 || i>L->length+1) {
		printf("输入不合法");
		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;
}
 
int main() {
	SqList L;
	InitList(&L); //初始化数组 
	for(int i=0; i<8; i++) { //给数组赋值【1-9】 
		L.data[i]=(i+1);
		L.length++;
	}
	for(int i=0; i<L.length; i++) //查看插入前的顺序表 
		printf("%d ",L.data[i]);
	printf("\n");
	bool result = ListInsert(&L, 4, 14); //在第4个位序插入14 
	for(int i=0; i<L.length; i++)
		printf("%d ",L.data[i]);
	return 0;
}

4.顺序表删除

基本操作：

         ListDelete(&L,i,&e)：删除第i个元素，并取回删除的值

//顺序表删除 ListDelete(&L,i,&e)
 
#define MaxSize 10
#include<stdio.h>
#include <stdbool.h>
 
typedef struct { //定义数组结构体 
	int data[MaxSize];
	int length;
}SqList;
 
//初始化顺序表 
void InitList(SqList *L) {
	for(int i=0; i<MaxSize; i++) //数组内元素置为0 
		L->data[i] = 0;
	L->length = 0;
}
 
//顺序表删除 
bool ListDelete(SqList *L, int i, int *e) { //删除第i个元素，并取回删除的值 
	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); //初始化顺序表 
	for(int i=0; i<8; i++) { //将顺序表赋值为【1-8】 
		L.data[i]=(i+1);
		L.length++;
	}
	int e = -1;
	if(ListDelete(&L, 3, &e)) //删除顺序表第3位元素，并返回该元素的值 
		printf("已删除元素%d ", e);
	else 
		printf("删除失败！"); 
	return 0; 
}

5.顺序表按位查找

基本操作：

         GetElem(&L,i)：查找第i位元素的值，并获取该值

//按位查找 GetElem(L,i)
 
#define MaxSize 10
#include<stdio.h>
 
typedef struct { //结构体数组定义顺序表 
    int data[MaxSize];
    int length; 
}SqList; 
 
//初始化顺序表 
void InitList(SqList *L) { //将顺序表初始化为0 
    for(int i=0; i<MaxSize; i++) 
        L->data[i] = 0;
    L->length = 0;
}
 
//函数的默认返回值就是int型
int GetElem(SqList *L, int i) { //查找第i位元素 
    return L->data[i-1]; //返回第i位元素的值 
}
 
int main() {
    SqList L;
    InitList(&L);
    for(int i=0; i<8; i++) { //顺序表赋值位【0-7】 
        L.data[i] = i;
        L.length++;
    }
    int e = GetElem(&L, 4); //查找第4位元素的值 
    printf("%d",e);
}

6.顺序表按值查找

基本操作：

        LocateElem(&L, e)：在顺序表中查找第一个值为e的元素，并返回其位序

//顺序表按值查找
 
# define MaxSize 10 
#include<stdio.h>
 
typedef struct{ //结构体定义顺序表 
	int data[MaxSize]; //数组 
	int length;
}SqList;
 
//初始化顺序表 
void InitList(SqList *L) { //将顺序表置为0 
	for(int i=0; i<MaxSize; i++) {
		L->data[i] = 0;
	}
	L->length = 0;
} 
 
//在顺序表中查找第一个值为e的元素，并返回其位序 
int LocateElem(SqList *L, int e) { 
	for(int i=0; i<L->length; i++)
		if(L->data[i] == e) 
			return i+1;
}
 
int main() {
	SqList L;
	InitList(&L);
	for(int i=0; i<8; i++) { //给顺序表赋值【8-1】 
		L.data[i] = 8-i;
		L.length++;
	}
	int Elem = 3;
	int d = LocateElem(&L, Elem);
	printf("%d", d);
}