day0804

最新推荐文章于 2024-10-16 12:19:08 发布

小嘉~230523

最新推荐文章于 2024-10-16 12:19:08 发布

阅读量136

点赞数 1

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_73743794/article/details/132136517

版权

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX 40
typedef int datatype;
typedef struct
{
	datatype data[MAX];
	int len;
}seqlist, *seqlistPtr;

//创建顺序表
seqlistPtr list_create();

//判满
int list_full(seqlistPtr S);

//判空
int list_empty(seqlistPtr S);

//向顺序表中添加元素
int list_add(seqlistPtr S,datatype e);

//遍历顺序表
void list_show(seqlistPtr S);

//任意位置插入元素
int list_insert_pos(seqlistPtr S, int pos, datatype e);

//任意位置删除元素
int list_delete_pos(seqlistPtr S, int pos);

//按位置进行修改
int list_update_pos(seqlistPtr S, int pos, datatype e);

//按值进行修改
int list_update_value(seqlistPtr S, datatype old_e, datatype new_e);

//查找指定位置的元素
datatype *list_search_pos(seqlistPtr S,int pos);

//按值进行查找元素,返回查找到的位置
int list_search_value(seqlistPtr S, datatype e);

//将顺序表排序，选择排序
void list_sort(seqlistPtr S, int flag);

//顺序表去重
void list_unique(seqlistPtr S);

//求最值操作
void datatype_list_mvalue(seqlistPtr S, int flag);

//顺序表反转
void list_reverse(seqlistPtr S);

//释放顺序表
void list_free(seqlistPtr *S);

#endif

#include "seqlist.h"
seqlistPtr list_create()
{
seqlistPtr S = (seqlistPtr)malloc(sizeof(seqlist));
	if(NULL==S)
	{
		printf("顺序表创建失败\n");
		return NULL;
	}
	memset(S->data, 0, sizeof(S->data));
	S->len = 0;
	printf("顺序表创建成功\n");
	return S;
}
//判满
int list_full(seqlistPtr S)
{
	if(NULL==S){
		printf("所给顺序表不合法\n");
		return 0;
	}
	return S->len == MAX;
}
//判空
int list_empty(seqlistPtr S)
{
	if(NULL == S)
	{
		printf("所给顺序表不合法\n");
		return 0;
	}
	return S->len == MAX;
}
//向顺序表中添加元素
int list_add(seqlistPtr S,datatype e)
{
	if(NULL==S || list_full(S))
	{
		printf("添加失败\n");
		return -1;
	}
	S->data[S->len] = e;

	S->len++;

	printf("添加成功\n");
	return 1;
}
/*
 * function:    遍历顺序表
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void list_show(seqlistPtr S)
{
	if(NULL==S || list_empty(S))
	{
		printf("遍历失败\n");
		return;
	}
	printf("当前数据表的元素为:\n");
	for(int i=0; i<S->len; i++){
		printf("%d\t",S->data[i]);
	}
	printf("\n");
}
int list_insert_pos(seqlistPtr S, int pos, datatype e)
{
	if(NULL==S || list_full(S) || pos<0 || pos>S->len)
	{
		printf("插入失败\n");
		return 0;
	}
	for(int i=S->len-1; i>=pos; i--)
	{
		S->data[i+1] = S->data[i];
	}
	S->data[pos] = e;
	S->len++;
	printf("插入成功\n");
	return 1;
}
/*
 * function:    删除元素
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int list_delete_pos(seqlistPtr S, int pos)
{
	if(NULL==S || list_full(S) || pos<0 || pos>=S->len)
	{
		printf("删除失败\n");
		return 0;
	}
	for(int i=pos+1 ; i<S->len ; i++)
	{
		S->data[i-1]=S->data[i];
	}
	S->len--;
	printf("删除成功\n");
	return 1;
}
/*
 * function:    按位置修改元素
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int list_update_pos(seqlistPtr S, int pos, datatype e)
{
	if(NULL==S || list_empty(S) || pos<0 || pos>=S->len)
	{
		printf("修改失败\n");
		return 0;
	}
	S->data[pos]=e;
	printf("更新成功\n");
	return 1;
}
/*
 * function:    按值进行查找元素,返回查找到的位置
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int list_search_value(seqlistPtr S, datatype e)
{
	if(NULL==S || list_empty(S))
	{
		printf("查找失败，顺序表为空");
		return -1;
	}
	for(int i=0 ; i<S->len ; i++){
		if(e == S->data[i])
		{
			return i;
		}
	}
		return -1;//没找到返回-1
}
/*
 * function:   按值进行修改 
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int list_update_value(seqlistPtr S, datatype old_e, datatype new_e)
{
	if(NULL==S || list_empty(S) || old_e==new_e){
		printf("修改失败\n");
		return 0;
	}
	int index =-1;
	while((index=list_search_value(S,old_e))>=0)
	{
		list_update_pos(S, index, new_e);
	}
	printf("修改成功\n");
	return 1;
}
/*
 * function:    查找指定位置的元素
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype *list_search_pos(seqlistPtr S,int pos)
{
	if(NULL==S || list_empty(S) || pos<0 || pos>S->len)
	{
		printf("查找失败\n");
		return NULL;
	}
	return &S->data[pos];
}
/*
 * function:    顺序表排序（1升序/0降序）
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void list_sort(seqlistPtr S, int flag)
{
	if(NULL==S || list_empty(S))
	{
		printf("排序失败，顺序表为空");
		return;
	}
	for(int i=0 ; i<S->len-1 ; i++){
		int min=i;
		for(int j=i+1 ; j<S->len ; j++){
			if(flag==1&&S->data[min] > S->data[j]||flag==0&&S->data[min] < S->data[j]){
				min=j;
			}
		}
		if(min!=i){
			S->data[i]^=S->data[min];
			S->data[min]^=S->data[i];
			S->data[i]^=S->data[min];
		}
	}
	printf("顺序表排序：\n");
	for(int i=0 ; i<S->len ; i++){
		printf("%d\t",S->data[i]);
	}
	putchar(10);
}
/*
 * function:    去重
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void list_unique(seqlistPtr S)
{
	if(NULL==S || S->len<=1)
	{
		printf("去重失败");
		return ; 
	}
	for(int i=0; i<S->len; i++)
	{
		for(int j=i+1; j<S->len; j++)
		{
			if(S->data[i] == S->data[j])
			{
				list_delete_pos(S,j);
				j--;
			}
		}
	}
	printf("去重成功\n");
}
/*
 * function:    求顺序表最值（1 max/0 min）
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void datatype_list_mvalue(seqlistPtr S, int flag)
{
	if(NULL==S || list_empty(S))
	{
		printf("顺序表为空");
		return;
	}
		int value=S->data[0];
	for(int i=0 ; i<S->len ; i++){
		if(flag==1 && value < S->data[i]){
			value=S->data[i];
		}
		else if(flag==0 && value > S->data[i]){
			value=S->data[i];
		}
	}
	printf("value=%d\n",value);
}
/*
 * function:    顺序表反转
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void list_reverse(seqlistPtr S)
{
	if(NULL==S || list_empty(S))
	{
		printf("顺序表为空");
		return;
	}
	for(int i=0 ; i<S->len/2 ;i++){
		datatype temp=S->data[i];
		S->data[i]=S->data[S->len-1-i];
		S->data[S->len-1-i]=temp;
	}
	printf("顺序表反转:\n");
	for(int i=0 ; i<S->len ; i++){
		printf("%d\t",S->data[i]);
	}
	putchar(10);
}
/*
 * function:    释放顺序表
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void list_free(seqlistPtr *S)
{
	if(NULL != *S)
	{
		free(*S);
		*S=NULL;
	}
	printf("释放表成功\n");
}

#include "seqlist.h"
int main(int argc, const char *argv[])
{
	//申请一个顺序表
seqlistPtr S = list_create();
	if(NULL==S)
	{
		return -1;
	}
	//调用添加函数
	list_add(S,3);
	list_add(S,8);
	list_add(S,5);
	list_add(S,4);
	//调用遍历函数
	list_show(S);
	//调用插入函数
	list_insert_pos(S, 3, 88);
	list_show(S);
	//调用删除函数
	list_delete_pos(S, 2);
	list_show(S);
	//调用修改函数
	list_update_pos(S, 1, 18);
	list_show(S);
	//调用查找函数
	printf("元素的位置为：");
	printf("%d\n",list_search_value(S,88));
	//调用按值修改元素
	list_update_value(S, 3, 9);
	list_show(S);
	//调用按位置查找函数
	datatype *p=list_search_pos(S, 2);
	if(NULL!=p){
	//	*p=999;
		printf("data[2]==%d\n",*p);
	}
	list_show(S);
	//去重
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);
	list_add(S,999);

	list_show(S);
	list_unique(S);
	list_show(S);
	//排序
	list_sort(S,0);
	//最值
	datatype_list_mvalue(S,0);
	//反转
	list_reverse(S);
	//释放
	list_free(&S);
	list_show(S);
	return 0;
}