完成顺序表

作业需求如下：

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

实现过程如下：

seqlist.h文件实现函数申明：

#ifndef  __SEQLIST_H__
#define __SEQLIST_H__

#define  MAX 20
typedef int datetype;

typedef struct
{
	datetype date[MAX];
	int len;

}seqlist;

//函数声明

//创建顺序表
seqlist *list_create();
//判空
int list_empty(seqlist *L);

//判满
int list_full(seqlist *L);
//添加元素
int list_add(seqlist *L,datetype e);
//遍历
void list_show(seqlist *L);
//任意位置插入
int list_insert_pos(seqlist *L,int pos,datetype e);

//任意位置删除
int list_delete_pos(seqlist *L, int pos);
//按位置修改
int list_updata_pos(seqlist *L,int pos,datetype new_e);

//按值修改
int list_updata_value(seqlist*L,datetype e,datetype f);
//按位置查找
int list_search_pos(seqlist *L,datetype e);
//按值查找 
int list_search_value(seqlist *l,datetype e);
//排序
int list_sort(seqlist *L);

//最值
int list_max(seqlist *L);
int list_min(seqlist *L);
//去重
int list_removal(seqlist *L);
//销毁

void list_free(seqlist *L);



#endif

seqlist.c文件实现函数的封装：
 

#include "seqlist.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
//函数定义
                               
 //创建顺序表
 seqlist *list_create()
{
	//在堆区申请一个顺序表大小的空间；
	//将该空间的起始地址赋值指针变量报错
	seqlist *L=(seqlist*)malloc(sizeof(seqlist));
	if(NULL==L)
	{
		printf("创建失败\n");
		return NULL;
	}
	//给顺序表初始化
	L->len=0;
	//给数组初始化
	memset(L,0,sizeof(datetype)*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,datetype e)
{
	//判断逻辑
	if(list_full(L))
	{
		printf("表满，添加失败\n");
		return 0;
	}
	//添加逻辑
	L->date[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->date[i]);
   }
   printf("\n");
}

 //任意位置插入        
int list_insert_pos(seqlist *L,int pos,datetype e)
{
	//判断逻辑
	if(list_full(L) || pos<0 || pos>L->len)
	{
		printf("插入失败\n");
		return 0;
	}

	//腾空过程
	for(int i=L->len-1;i>=pos;i--)
	{
		L->date[i+1] = L->date[i]; //循环将当前的元素放到后面的一个元素中；

	}
	//插入数据
	L->date[pos] = e; //将要插入的数据放到腾出的空当中

	//表长变化
	L->len++;
	printf("插入成功\n");
	return 0;
}
 
 //任意位置删除        
 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+1;i<L->len;i++)
	{
		L->date[i-1]=L->date[i];
	}
	//表长变化
	L->len--;
	printf("删除成功\n");
	return 1;
}
 //按位置修改                  
int list_updata_pos(seqlist *L,int pos,datetype new_e)
{
	//判断逻辑
	if(list_empty(L) || pos<0 || pos>=L->len)
	{
		printf("修改失败\n");
		return 0;
	}

	//更新逻辑
	L->date[pos] = new_e;
	printf("更新成功\n");
	return 1;
	
}
 //按值修改
 
int list_updata_value(seqlist*L,datetype e,datetype f)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("按值更新失败\n");
		return -2;
	}

	//更新逻辑
	for(int i=0;i<L->len;i++)
	{
	   if(L->date[i]==e)
	   {
		L->date[i]=f;
		printf("按值更新成功\n");
		return 0;
	   }
	}
	printf("按值更新失败\n");
	return -1;

}
 //按位置查找
 
int list_search_pos(seqlist *L,int pos)
{
	//判断逻辑
	if(list_empty(L) || pos<0 || pos>=L->len)
	{
		printf("查找失败\n");
		return -2;
	}
	//查找逻辑
	return L->date[pos-1];
	printf("查找成功\n");
}
 //按值查找                   
int list_search_value(seqlist *L,datetype e)
{
	//判断逻辑
	if(list_empty(L))
	{
		printf("查找失败\n");
		return -2;
	}
	//查找逻辑
	for(int i=0; i<L->len;i++)  //查找成功
	{
		if(L->date[i]==e)
		{
			return i;
		}
	}
	return -1;  //没找到返回-1

}
 //排序      
 int list_sort(seqlist *L)
{
	seqlist t;
	for(int i=1;i<L->len;i++)
	{
		for(int j=0;j<L->len-i;j++)
		if(L->date[j]>L->date[j+1]) //控制排序方式，从大到小或者从小到大
		{
			 t.date[j]=L->date[j];
			L->date[j]=L->date[j+1];
			L->date[j+1]=t.date[j]; //三杯水交换法
		}
			
	}
}

 //最值 
 //求最大值
 int list_max(seqlist *L)
{
	int max=0;  //存放最值容器，作为返回值
	for(int i=0;i<L->len;i++)
	{
		if(max<L->date[i])
		{
			max=L->date[i];
		}
	}
	return max;
}
//求最小值
int list_min(seqlist *L)
{
	int min=L->date[0];
	for(int i=0;i<L->len;i++)
	{
		if(min>L->date[i])
		{
			min=L->date[i];
		}
	}
	return min;
}

 //去重  
 int list_removal(seqlist *L)
{
	int j=0;
	int i;
	for( i=0;i<L->len;i++)
	{
		if(L->date[j]!=L->date[i]) //如果i，j下标对应值不同则i，j均自增
			                       //否则只有i自增，j不自增
		{
			j++;
		}
		L->date[j]=L->date[i];
	}
	L->len=L->len-(i-j-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,8);
	list_add(L,2);
	list_add(L,4);
	list_add(L,8);
	list_add(L,2);
	list_add(L,4);

	//调用遍历函数
	list_show(L);
	
	//调用插入函数
	list_insert_pos(L,1,9);
	list_show(L);
	
	//调用删除函数
	list_delete_pos(L,2);
	list_show(L);
	
	//调用修改函数
	list_updata_pos(L,0,100);
	list_show(L);
	//调用按值修改
	list_updata_value(L,9,3);
	list_show(L);

	//测试按位置查找函数
	int pos1 = list_search_pos(L,1);
	if(pos1>=0)
	{
		printf("您查找的位置的值为%d\n",pos1);
	}
	
	
	//测试按值查找函数
	int pos = list_search_value(L,100);
	if(pos>=0)
	{
		printf("您要查找的值在%d位置\n",pos+1);

	}
	else
	{
		printf("查找失败\n");
	}

	//测试排序
	list_sort(L);
	printf("数组内值从小到大排序为：\n");
	list_show(L);

	//测试最值
	//最大值
	int max=list_max(L);
	printf("数组最大值为%d\n",max);
	//最小值
	int min=list_min(L);
	printf("数组最小值为%d\n",min);

	//测试去重
	list_removal(L);
	list_show(L);



	//测试销毁函数
	list_free(L);
	L=NULL;
	list_show(L);
	return 0;
}

实现效果如下：

ubuntu@ubuntu:02_day$ gcc *.c
ubuntu@ubuntu:02_day$ ./a.out 
创建成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
此时顺序表中元素分别是： 3	8	2	4	8	2	4	
插入成功
此时顺序表中元素分别是： 3	9	8	2	4	8	2	4	
删除成功
此时顺序表中元素分别是： 3	9	2	4	8	2	4	
更新成功
此时顺序表中元素分别是： 100	9	2	4	8	2	4	
按值更新成功
此时顺序表中元素分别是： 100	3	2	4	8	2	4	
您查找的位置的值为100
您要查找的值在1位置
数组内值从小到大排序为：
此时顺序表中元素分别是： 2	2	3	4	4	8	100	
数组最大值为100
数组最小值为2
此时顺序表中元素分别是： 2	3	4	8	100	
销毁成功
空空如也，遍历失败
ubuntu@ubuntu:02_day$