创建顺序表，并实现判空、判满、添加元素、遍历、任意位置插入、任意位置删除、按位置修改、按值修改、按位置查找、按值查找、排序、最值、去重、销毁程序

 实现过程：

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,5);
	list_add(L,5);
	list_add(L,5);
	list_add(L,7);
	list_add(L,9);
	list_add(L,9);
	list_add(L,9);

	//使用遍历函数
	list_show(L);

	//使用任意位置插入函数
	list_insert_pos(L,1,6);
	list_show(L);

	//使用使用删除函数
	list_delete_pos(L,3);
	list_show(L);

	//使用按位置修改函数
	list_update_pos(L,0,0);
	list_show(L);

	//使用按值修改函数
	list_update_value(L,10,8);
	list_show(L);

	//使用按位置查找函数
	int value=list_search_pos(L,0);

	//使用按值查找函数
	int pos=list_search_value(L,9);
	if(pos>=0)
	{
		printf("您查找的元素在第%d个位置\n",pos);
	}
	else
	{
		printf("查找失败\n");
	}

	//使用排序函数
	list_sort(L);
	list_show(L);
	
	//使用求最值函数
	int max=list_max(L);
	if(max==0)
	{
		printf("求最大值失败");
	}
	else
	{
		printf("最大值=%d\n",max);
	}
	
	//使用去重函数
	list_delete_repeat(L,5);
	list_delete_repeat(L,9);
	list_show(L);

	//销毁顺序表
	list_free(L);
	L=NULL;
	list_show(L);

	return 0;
}

 seqlist.c功能函数文件

#include "seqlist.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//函数的定义
//创建顺序表
seqlist *list_create()
{
	//在堆区申请一个顺序表大小的空间
	//将该空间的起始地址赋值给指针变量保存
	seqlist *L=(seqlist*)malloc(sizeof(seqlist));
	if(L==NULL)
	{
		printf("申请失败\n");
		return NULL;
	}
	//顺序表初始化
	L ->len=0;
	
	//数组初始化
	memset(L,0,sizeof(datatype)*MAX);

	printf("创建成功\n");
	//将创建好的顺序表返回
	return L;
}

//判空
datatype list_empty(seqlist *L)
{
	return L ->len==0; //1表示空，0表示不空

}

//判满
datatype list_full(seqlist *L)
{
	return L ->len==MAX; //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(L==NULL || list_empty(L))
	{
		printf("遍历失败\n");
		return;
	}

	//遍历逻辑
	printf("此时顺序表中的元素分别是：\n");
	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-1; i>=pos; i--)
	{
		//将当前元素放到后面一个元素中
		L->data[i+1] = L->data[i];
	}

	//插入数据到腾出的位置中
	L->data[pos] = e;
	
	//表长变化
	L->len++;

	printf("插入成功\n");
	return 1;
}

//任意位置删除
int list_delete_pos(seqlist *L,int pos)
{
	//判断逻辑
	if(list_empty(L) || pos<0 || pos>=L->len )
	{
		printf("删除失败\n");
		return 0;
	}

	//移动逻辑
	for(int i=pos;i<=L->len;i++)
	{
		//从要删除的元素的位置的后面的元素开始
		//依次覆盖前一位元素
		L->data[i]=L->data[i+1];
	}

	//表的变化
	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_update_value(seqlist *L,datatype e,datatype new_e)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("修改失败\n");
		return 0;
	}
	for(int i=0;i<L->len;i++)
	{
		if(L->data[i]==e)  //查找成功
		{
			L->data[i]=new_e; //将新的值赋值
			printf("修改成功\n");
	        return 1;
		}
	}
     printf("修改失败,没有这个值\n");
	 return 0;
}


//按位置查找
int list_search_pos(seqlist *L,int pos)
{
	//判断逻辑
	if(list_empty(L) || pos<0 || pos>L->len)
	{
		return 0; //返回0查找失败
	}

	//查找逻辑
	for(int i=0;i<L->len;i++)
	{
		if(pos==i)  //查找成功
		{
			printf("您查找的元素的值是%d\n",L->data[i]);
			return 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; //返回下标
		}
	}
	printf("没有这个值\n");
	return -1;//查找了，但没有找到
}

//排序
int list_sort(seqlist *L)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("排序失败\n");
		return 0;
	}

	//冒泡排序
	for(int i=1;i<L->len;i++)
	{
		for(int j=0;j<L->len-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("排序成功\n");
	return 1;
}


//求最值
int list_max(seqlist *L)
{
	//判断逻辑
	if(list_empty(L))
	{
		//printf("求值失败\n");
		return 0;
	}

	//求最大值
	int max=L->data[0];
	for(int i=1;i<L->len;i++)
	{
		if(max<L->data[i]);
		{
			max=i;
		}
	}
	printf("求最大值成功");
	return L->data[max];
}


//去重
int list_delete_repeat(seqlist *L,datatype e)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("去重失败\n");
		return 0;
	}

	//去除重复的值
	int i=0,j=0;
	while(i<L->len)
	{
		if(L->data[i]==e&&i!=j)  //将除了第一个重复值以外的重复值去除
		{
			i++;
		}
		else
		{
     		L->data[j]=L->data[i];  //将不重复的元素依次排放
			i++;
			j++;

		}
	}
	L->len=j; //去除后的顺序表长度
	printf("去重成功\n");
	return 1;
}

//销毁
void list_free(seqlist *L)
{
	if(L!=NULL)
	{
		free(L);
		L=NULL;
		printf("销毁成功\n");
	}
}

 声明函数文件：

#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_update_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_max(seqlist *L);

//去重
int list_delete_repeat(seqlist *L,datatype e);

//销毁
void list_free(seqlist *L);



#endif