完成顺序表的按值修改、按位置查找、排序、最值、去重

代码：

seqlist.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#define max 20  //数组最大容量
typedef int datatype;  //类型重定义

//定义顺序表类型
typedef struct
{
	datatype data[max];  //存储顺序表的数组
	int len;      //顺序表的长度
}seqlist;

//函数声明



//创建顺序表
seqlist *list_create();
//判空
int list_empty(seqlist *l);
//判满
int list_full(seqlist *l);
//添加元素
int list_add(seqlist *l,datatype e);
//遍历
void list_show(seqlist *l);
//任意位置插入
int list_insert_pos(seqlist *l,int pos,datatype e);
//任意位置删除
int list_delete_pos(seqlist *l,int pos);
//按位置修改
int list_update_pos(seqlist *l,int pos,datatype new_e);
//按值修改
int list_updata_value(seqlist *l,datatype e,datatype new_e);
//按位置查找
int list_search_pos(seqlist *l,int pos);
//按值查找
int list_search_value(seqlist *l,datatype e);
//排序
int list_sort(seqlist *l);
//求最大值
int list_Maxi(seqlist *l);
//求最小值
int list_min(seqlist *l);
//去重
int list_quchong(seqlist *l);
//销毁
void list_free(seqlist *l);

#endif

seqlist.c

#include"seqlist.h"      //引用头文件
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
// #include<maclloc.h>
//函数定义



//创建顺序表
seqlist *list_create()
{
	//在堆区申请一个顺序表大小的空间
	//将该空间的起始地址赋值给指针变量报错
	seqlist *l=(seqlist*)malloc(sizeof(seqlist));
	if(NULL==l)
	{
		printf("创建失败\n");
		return NULL;
	}
	//给顺序表初始化
	l->len=0;//结构体的指针访问结构体成员用指针访问
	//给数组初始化
	memset(l,0,sizeof(datatype)*max);
	printf("创建成功\n");
	return l;    //将创建好的顺序表返回
}
//判空
int list_empty(seqlist *l)
{
	return l->len==0 ? 1:0;  //1表示空 0表示非空
}
//判满
int list_full(seqlist *l)
{
	return l->len==max ? 1:0; //1表示满 0表示不满
}
//添加元素
int list_add(seqlist *l,datatype e)
{
	//判断逻辑
	if(list_full(l))
	{
		printf("表满，添加失败\n");
		return 0;
	}
	//添加逻辑
	l->data[l->len]=e;//将要添加的元素放入顺序表
	//第一个没有存放数据元素的数组中
	//表的变化
	l->len++;
	printf("添加成功\n");
	return 1;
}
//遍历
void list_show(seqlist *l)
{
	//判断逻辑
	if(NULL==l||list_empty(l))
	{
		printf("空空如也，遍历失败\n");
		return;
	}
	//遍历逻辑
	printf("此时顺序表中的元素分别是：");
	for(int i=0;i<l->len;i++)
	{
		printf ("%d\t",l->data[i]);
	}
	printf("\n");
}
//任意位置插入
int list_insert_pos(seqlist *l,int pos,datatype e)
{
	//判断逻辑 
	if(list_full(l)||pos<0||pos>l->len)
	{
		printf("插入失败\n");
		return 0;
	}
	//腾空过程
	for (int i=l->len;i>=pos;i--)
	{
		l->data[i+1]=l->data[i];  //循环将当前的元素放到后一个元素中
	}
	//插入数据
	l->data[pos]=e;  //将要插入的数据放入制定腾出的空中
	//表长变化
	l->len++;
	printf("插入成功\n");
	return 0;
}
//任意位置删除
int list_delete_pos(seqlist *l,int pos)
{
	//判断逻辑
	if (list_empty(l)||pos>=l->len||pos<0)
	{
		printf("删除失败\n");
		return 0;
	}
	//移动逻辑
	for (int i=pos+1;i<l->len;i++) 
	{
		l->data[i-1]=l->data[i];    //将当前元素向前移动一格
	}
	//表的变化
	l->len--;
	printf("删除成功\n");
	return 1;
}
//按位置修改
int list_update_pos(seqlist *l,int pos,datatype new_e)
{
	//判断逻辑
	if (list_empty(l)||pos<0||pos>=l->len)
	{
		printf("修改失败\n");
		return 0;
	}
	//更新逻辑
	l->data[pos]=new_e;
	printf("更新成功\n");
	return 1;
}
//按值修改
int list_updata_value(seqlist *l,datatype e,datatype new_e)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("空数组按值修改失败\n");
		return -2;
	}
	//修改逻辑
	for(int i=0;i<l->len;i++)     //遍历真个数组
	{
		if(l->data[i]==e)      //先查找需要改的元素
		{
			l->data[i]=new_e;       //将输入的新的数值代替
			return 1;
		}
		else
		{
			printf("值不存在，按值修改失败\n");
			return -1;
		}
	}
}
//按位置查找 
int list_search_pos(seqlist *l,int pos)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("查找失败\n");
		return -2;
	}
	//按位置查找逻辑
	for (int i=0;i<l->len;i++)
	{
		if(pos==i)
		{
			return l->data[pos-1];
		}
	}
}
//按值查找
int list_search_value(seqlist *l,datatype e)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("查找失败\n");
		return -2;
	}
	//查找逻辑
	for(int i=0;i<l->len;i++)
	{
		if(l->data[i]==e)   //查找成功
		{
			return i;
		}
	}
	return -1;    //没找到则返回-1
}
//排序
int list_sort(seqlist *l)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("该数组为空不能排序\n");
		return 0;
	}
	//排序逻辑

	for(int i=0;i<l->len-1;i++)
	{
		for(int j=i;j<l->len-1-i;j++)
		{
			if(l->data[j]>l->data[j+1])
			{
				int temp=l->data[j];
				l->data[j]=l->data[j+1];
				l->data[j+1]=temp;
			}
		}
	}
	printf("从小到大的排序完成");
	return 1;
}
//求最值
int list_Maxi(seqlist *l)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("该数组为空不能排序\n");
		return 0;
	}
	//最大值排序逻辑
	int zuida=l->data[0];
	for(int i=0;i<l->len;i++)
	{
		if(zuida<l->data[i])
		{
			zuida=l->data[i];
		}
	}
	return zuida;
}
//最小值
int list_min(seqlist *l)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("该数组为空不能排序\n");
		return 0;
	}
	//最小值排序逻辑
	int min=l->data[0];
	for(int j=0;j<l->len;j++)
	{
		if(min>l->data[j])
		{
			min=l->data[j];
		}
	}
	return min;
}
//去重
int list_quchong(seqlist *l)
{
	//判断逻辑
	if(list_empty(l))
	{
		printf("该数组为空不能去重\n");
		return 0;
	}

	//去重逻辑
	for (int i=0;i<l->len-1;i++)
	{
		for(int j=i+1;j<l->len;j++)
		{
			if(l->data[i]==l->data[j])
			{
				for(int k=j+1;k<l->len;k++)
				{
				l->data[k-1]=l->data[k];
				}
				l->len--;
				printf("有重复元素已完成去重");
			}
		}
	}
return 1;
}
//销毁
void list_free(seqlist *l)
{
	if(l !=NULL)
	{
		free(l);
		l=NULL;
		printf("销毁成功\n");
	}
}

main.c

#include"seqlist.h"//引用头文件
#include <stdio.h>

int main(int argc, const char *argv[])
{
	//调用创建函数创建一个顺序表
	seqlist *l=list_create();
	if(NULL==l)
	{
		return -1;
	}
	//调用添加函数
	list_add(l,3);
	list_add(l,1);
	list_add(l,2);
	list_add(l,4);
	list_add(l,8);
	list_add(l,5);
	//调用遍历函数
	list_show(l);
	//调用任意位置插入函数
	list_insert_pos(l,1,9);
	list_show(l);
	//调用任意位置删除函数
	list_delete_pos(l,1);
	list_show(l);
	//调用按位置修改函数
	list_update_pos(l,0,9);
	list_show(l);
	//调用按位置查找函数
	int loc=list_search_pos(l,2);
	if (loc>=0)
	{
		printf("查找的位置的数值是%d\n",loc);
	}
	else
	{
		printf("查找失败\n");
	}

	//调用按值修改函数
	list_updata_value(l,1,9);
	list_show(l);
	//调用按值查找函数
	int pos=list_search_value(l,2);
	if(pos>=0)
	{
		printf("serch的值在第%d格位置\n",pos+1);
	}
	else
	{
		printf("查找失败\n");
	}
	//调用排序函数
	list_sort(l);
	list_show(l);
	//调用求最大值函数
	int m=list_Maxi(l);
	printf("最大值为%d\n",m);
	//调用最小值函数
	int n=list_min(l);
	printf("最小值为%d\n",n);
	//调用去重函数
	list_quchong(l);
	list_show(l);
	//测试销毁函数
	list_free(l);
	l=NULL;
	list_show(l);
	return 0;
}

效果展示：

（1）去重，取最值 按位置查找 按值修改效果：

 

 

（2）排序效果图