数据结构之顺序表：

封装功能函数，调用功能函数，申请堆区空间，

顺序表的操作

一.创建一个顺序表：

1.在堆区申请(堆区申请的空间不会随着函数函数的调用结束而自动回收)，所以需要用到free函数程序员手动释放，而栈区是随着函数调用结束后自动回收，但是是最后进入栈区的最先被销毁，作用是将申请的空间返回给主函数使用，其他函数也可以通过该指针进行处理顺序表里的内容

2.判断是否申请成功，如果不成功返回NULL

3.申请成功需要初始化，数组容器初始化和长度初始化（数组容器可以不初始化但是长度必须初始化）

Club_ptr creat()在堆区申请一个空间返回申请到空间的地址
{
	Club_ptr C=(Club_ptr)malloc(sizeof(Club));
	if(NULL == C)
	{
		printf("申请失败\n");
		return NULL;
	}
	C->len=0;
	printf("申请成功\n");
	return C;
}

初始化数组容器可以使用memset函数

二.判满操作

判满意味着判断顺序表是否已满，即已经达到了顺序表所能容纳的最大元素个数。

1.判断传过来的顺序表的合法性，即传过来的是NULL，如果是个NULL就没必要做判断啦

2、如果合法判断表的长度是否达到了最大值，可以返回一个整数，如果满了返回1，否则返回0；

int list_full(Club_ptr S)//定义一个判满函数从实参传过来申请的空间
{
    if(NULL==S)//判断是否合法
    {
        printf("表不合法")；
        return 0;
    }
    return S->len==MAX;//合法满了
    //也可以
    else if(S->len==MAX)
    {
        printf("表满了")；
        return 1；
    }
    
}

三.判空操作

判空操作用于判断顺序表是否为空，即没有存储任何元素。

1.和判满类似，判断合法性

2.合法判断表的长度是否为0;

int list_empty(Club_ptr S)//定义一个判满函数从实参传过来申请的空间
{
    if(NULL==S)//判断是否合法
    {
        printf("表不合法")；
        return 0;
    }
    return S->len==0;//合法空的
    //也可以
    else if(S->len==0)
    {
        printf("表为空")；
        return 1；
    }
    
}

四：添加数据操作

顺序表的添加数据元素操作通常分为两个部分：判断是否可以添加元素（判满）和实际添加元素

1.判断表是否合法，并且是否满了

2.将要添加的数据放到顺序表长度所指向的那个数组元素中（表的末尾）即可

3.添加数据长度要更新（自增）

4.成功返回1，失败返回0，需要顺序表和要添加的元素

int Club_add(Club_ptr S)
{
	if(NULL == S)
	{
		printf("添加失败");
		return 0;
	}
	printf("姓名\t性别\t年龄\t身高\n");
	scanf("%s %c %d %lf",\
			S->data[S->len].name,\
			&S->data[S->len].sex,\
			&S->data[S->len].age,\
			&S->data[S->len].hight);
	S->len++;
	printf("添加成功\n");
	return 1;
}

 五.顺序表的遍历

顺序表的遍历操作是指按照一定的顺序依次访问顺序表中的所有元素。需要判断表是否合法是否为空

1. 使用循环结构（如for循环、while循环）从顺序表的第一个元素开始，逐个遍历到最后一个元素。

2. 在每次遍历过程中，可以通过获取当前索引位置的元素值，进行一些自定义的操作（如打印、处理等）。

3. 继续循环直到遍历完所有元素，即索引达到顺序表的长度（已存储元素个数）。

int Club_show(Club_ptr S)
{
	if(NULL==S || Club_empty(S) )
	{
		printf("遍历失败\n");
		return 0;
	}
	printf("姓名\t性别\t年龄\t身高\n");
	for(int i=0;i<S->len;i++)
	{
		printf("%s\t%c\t%d\t%.2lf\n",\
				S->data[i].name,\
				S->data[i].sex,\
				S->data[i].age,\
				S->data[i].hight);
	}
	return 1;
}
 

 六.任意位置插入元素

 

 

1. 检查插入位置的有效性，确保插入位置在顺序表的范围内（通常为0到length之间）。如果插入位置超出了范围，则插入失败，给出相应的提示或返回错误信息。

2. 为了在指定位置插入元素，你需要将插入位置后的所有元素向后移动一位，为新元素腾出空间。

3. 在插入位置处插入新元素。

4. 更新顺序表的长度（已存储元素个数）。

int Club_pos_add(Club_ptr C)
{
	int a;
	printf("请输入插入的位置");
	scanf("%d",&a);
	if(NULL == C || Club_empty(C) || a<1 || a>C->len)//判断合法性且插入位置是否合理
	{
		printf("插入失败\n");
		return 0;
	}
	for(int i=C->len;i>=a-1;i--)//遍历插入位置的后面所有的元素并且后移腾位置
	{
		C->data[i+1]=C->data[i];再将赋值给移动后的位置
	}
	printf("姓名\t性别\t年龄\t身高\n");
	scanf("%s %c %d %lf",\
			C->data[a-1].name,\
			&C->data[a-1].sex,\
			&C->data[a-1].age,\
			&C->data[a-1].hight);
	C->len++;//更新长度
	printf("添加成功\n");
	return 1;
}
 

 七.任意位置删除

 

1. 检查删除位置的有效性，确保删除位置在顺序表的范围内（通常为0到length-1之间）。如果删除位置超出了范围，则删除失败，给出相应的提示或返回错误信息。

2. 从删除位置开始，将该位置后面的所有元素向前移动一位，覆盖要删除的元素。

3. 更新顺序表的长度（已存储元素个数）。

   int Club_pos_delete(Club_ptr C)
   {
   	int a;
   	printf("请输入删除的位置");
   	scanf("%d",&a);
   	if(NULL == C || Club_empty(C) || a<=0 ||a>C->len)
   	{
   		printf("删除错误\n");
   		return 0;
   	}
    
   			for(int i=a-1;i<C->len;i++)
   			{
   			C->data[i]=C->data[i+1];
   			}
   		C->len--;
   		printf("删除成功\n");
   		return 1;
   }
   

八.按位置修改

1. 检查指定位置是否有效，确保指定位置在顺序表的范围内（通常为0到length-1之间）。如果指定位置超出了范围，则修改失败，给出相应的提示或返回错误信息。

2. 根据指定位置，定位到要修改的元素。

3. 进行相应的修改操作，将新的元素值赋给指定位置的元素。

 

int Club_pos_mod(Club_ptr C)
{
	int a;
	printf("请输入修改的位置");
	scanf("%d",&a);
	if(NULL == C || Club_empty(C) || a<=0 ||a>=C->len)
	{
		printf("修改错误\n");
		return 0;
	}
	printf("姓名\t性别\t年龄\t身高\n");
	scanf("%s %c %d %lf",\
			C->data[a-1].name,\
			&C->data[a-1].sex,\
			&C->data[a-1].age,\
			&C->data[a-1].hight);
	printf("修改成功\n");
	return 1;
	
}

九. 按元素查找

1. 使用循环结构（如for循环、while循环）遍历顺序表中的每个元素。

2. 在每次遍历过程中，将当前元素与目标元素进行比较。

3. 如果找到了与目标元素相匹配的元素，返回该元素的位置或其他信息。

4. 如果顺序表中没有与目标元素匹配的元素，则返回查找失败的信息。

int Club_name_find(Club_ptr C)
{
	char a[20];
	printf("请输入查找的名字：");
	scanf("%s",a);
	if(NULL == C || Club_empty(C))
	{
		printf("查找失败\n");
		return 0;
	}
	for(int i=0;i<C->len;i++)
	{
		if(strcmp(C->data[i].name,a)==0)
		{
			printf("查找成功\n");
			printf("姓名\t性别\t年龄\t身高\n");		
			printf("%s\t%c\t%d\t%.2lf\n",\
				C->data[i].name,\
				C->data[i].sex,\
				C->data[i].age,\
				C->data[i].hight);
		}
	}
	return 1;
}
 

 

十.排序

1. 从顺序表的第一个元素开始，依次比较相邻的两个元素。

2. 如果当前元素大于（或小于）后一个元素，就交换它们的位置，将较大（或较小）的元素“冒泡”到右侧。

3. 继续比较下一对相邻元素，重复上述步骤，直到遍历完整个顺序表。

4. 重复上述过程，直到没有发生任何交换操作，即顺序表已完全排序。 

void Club_sort(Club_ptr C)
{
	if(NULL == C || Club_empty(C))
	{
		printf("排序不成功\n");
		return;
	}
	int fleg;
	printf("输入0或1来控制升序或降序:");
	scanf("%d",&fleg);
	for(int i=1;i<C->len;i++)
	{
		for(int j=0;j<C->len-i;j++)
		{
			if(fleg == 1)
			{
				if(C->data[j].age<C->data[j+1].age)
				{
					datatype temp;
					temp=C->data[j];
					C->data[j]=C->data[j+1];
					C->data[j+1]=temp;
				}
			}	
			if(fleg == 0 )
			{
				if(C->data[j].age>C->data[j+1].age)
				{
					datatype temp;
					temp=C->data[j];
					C->data[j]=C->data[j+1];
					C->data[j+1]=temp;
				}
			}
 
		}
	}
}
 

 十一：释放

1. 遍历顺序表，释放每个元素占用的内存空间。如果有动态分配的内存，则需要逐个释放。

2. 释放顺序表本身占用的内存空间。

void Club_free(Club_ptr C)
{
	if(NULL != C)
	{
		free(C);
		C=NULL;
	}
}

 当然除了这些还有很多功能，但是封装一个功能函数都需要判断合法性以及核心逻辑以及考虑它的返回值，kill顺序表