顺序表的增删改查和排序及去重还有两个有序顺序表的和并

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

//定义线性表长度
#define MAXSIZE 20 
//给数据类型取一个别名
typedef int datatype;

//定义一个结构体
typedef struct 
{
	//数据元素
	datatype data[MAXSIZE];
	//顺序表长度
	int len;
}Seqlist;


Seqlist *create();
int insert_rear(Seqlist *list, datatype e);
void output(Seqlist *list);
int delete_rear(Seqlist *list);
int search_sub(Seqlist *list, int sub);
int update_sub(Seqlist *list, int sub, int e);
int insert_sub(Seqlist *list, int sub, datatype e);
int delete_sub(Seqlist *list, int sub);
int search_data(Seqlist *list, datatype key);
int update_data(Seqlist *list, datatype key, datatype e);
int delete_data(Seqlist *list, datatype key);
int insert_data(Seqlist *list, datatype key, datatype e);
void remove_same(Seqlist *list);
void bubble_seqlist(Seqlist *list);
void simple_choose_seqlist(Seqlist *list);
void combine_seqlist(Seqlist *lc, Seqlist *la, Seqlist *lb);
Seqlist *free_space(Seqlist *list);
#endif

main.c

#include "head.h"

int main(int argc, char *argv[])
{
	Seqlist *list = create(); 

	//尾插
	int n;
	printf("请输入要插入的个数:");
	scanf("%d",&n);
	datatype e;
	for (int i = 0; i < n; i++)
	{
		//printf("请输入插入的值：");
		//scanf("%d",&e);
		insert_rear(list,i+1);
		//insert_rear(list,i+1);
		//insert_rear(list,i+1);
	}
	output(list);


	/*
	//尾删
	delete_rear(list);
	output(list);
	*/

	/*
	//按下标查找
	int sub;
	printf("请输入要查找的下标：");
	scanf("%d",&sub);
	printf("值为%d\n",search_sub(list,sub));
	*/

	/*
	//按下标修改
	printf("请输入要修改的下标\n");
	int sub;
	scanf("%d",&sub);
	printf("请输入要修改成的值\n");
	scanf("%d",&e);
	update_sub(list,sub,e);
	output(list);
	*/

	/*
	//按下标插入
	printf("请输入要插入的下标\n");
	int sub;
	scanf("%d",&sub);
	printf("请输入要插入的值\n");
	scanf("%d",&e);
	insert_sub(list, sub, e);
	output(list);	
	*/

	/*
	//按下标删除
	printf("请输入要删除的下标\n");
	int sub;
	scanf("%d",&sub);
	delete_sub(list,sub);
	output(list);
	*/

	/*
	//按元素查找
	datatype key;
	printf("请输入要查找的元素：");
	scanf("%d",&key);
	int sub = search_data(list, key);
	if (sub == -1)
	{
		puts("查找失败");
	}
	else
	{
		printf("查找的元素下标为%d\n", sub);
	}
	*/


	/*
	//按元素修改
	datatype key;
	printf("请输入需要查找的元素：");
	scanf("%d",&key);
	printf("请输入需要修改成的值");
	scanf("%d",&e);
	update_data(list, key, e);
	output(list);
	*/
		
	/*
	//按元素删除
	datatype key;
	printf("请输入需要删除的元素：");
	scanf("%d",&key);
	delete_data(list, key);
	output(list);
	*/

	/*
	//按元素插入
	datatype key;
	printf("请输入需要查找的元素：");
	scanf("%d",&key);
	printf("请输入需要插入的值");
	scanf("%d",&e);
	insert_data(list, key, e);
	output(list);
	*/

	/*
	//顺序表去重
	remove_same(list);
	output(list);
	*/

	/*
	//冒泡降序，简单选择升序
	bubble_seqlist(list);
	output(list);
	simple_choose_seqlist(list);
	output(list);
	*/

	/*
	//顺序表合并
	Seqlist la = {1, 3, 5, 7, 9};
	la.len = 5;
	Seqlist lb = {2, 4, 6, 8, 10, 12, 14};
	lb.len = 7;
	Seqlist lc;
	lc.len = 0;
	combine_seqlist(&lc, &la, &lb);
	output(&lc);
	*/

	//释放空间
	list = free_space(list);

	return 0;
}

test.c

#include "head.h"

/*
 * function:    在堆区申请顺序表空间
 * @param [ in] 
 * @param [out] 成功返回首地址，失败返回NULL
 * @return      
 */

Seqlist *create()
{
	Seqlist *list = (Seqlist *)malloc(sizeof(Seqlist));
	if (list == NULL)
	{
		return NULL;
	}
	//为数据元素初始化
	memset(list->data, 0, sizeof(list->data));
	//长度初始化，不然为一个随机值
	list->len = 0;
	return list;
}

/*
 * function:    判断顺序表是否已满
 * @param [ in] 顺序表长度
 * @param [out] 
 * @return      若满返回-1未满返回0
 */

int full_seqlist(Seqlist *list)
{
	return list->len==MAXSIZE?-1:0;
}

/*
 * function:    尾插
 * @param [ in] 顺序表 插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int insert_rear(Seqlist *list, datatype e)
{
	if (list == NULL || full_seqlist(list))
	{
		printf("插入失败\n");
		return -1;
	}

	list->data[list->len] = e;
	list->len++;
	return 0;
}

/*
 * function:    判断是否为空
 * @param [ in] 链表
 * @param [out] 
 * @return      为空返回-1非空返回0
 */

int empty_seqlist(Seqlist *list)
{
	return list->len == 0 ? -1 : 0;
}

/*
 * function:    遍历打印
 * @param [ in] 顺序表
 * @param [out] 
 * @return      
 */

void output(Seqlist *list)
{
	if (list == NULL || empty_seqlist(list))
	{
		printf("打印失败\n");
		return;
	}
	for (int i=0; i<list->len; i++)
	{
		printf("%d ", list->data[i]);
	} 
	puts("");
}

/*
 * function:    尾删
 * @param [ in] 顺序表
 * @param [out] 
 * @return      成功返回0失败返回-1
 */

int delete_rear(Seqlist *list)
{
	if (list == NULL || empty_seqlist(list))
	{
		printf("删除失败\n");
		return -1;
	}

	list->len--;
	return 0;
}


/*
 * function:    按下标查找
 * @param [ in] 顺序表 下标
 * @param [out] 
 * @return      失败返回-1成功返回下表对应的值
 */

int search_sub(Seqlist *list, int sub)
{
	if (list == NULL || empty_seqlist(list) || sub < 0 || sub >= list->len)
	{
		printf("查找失败\n");
		return -1;
	}

	return list->data[sub];
}

/*
 * function:    按下标修改
 * @param [ in] 顺序表 下标 修改的值
 * @param [out] 
 * @return      失败返回-1成功返回0
 */

int update_sub(Seqlist *list, int sub, int e)
{
	if (list == NULL || empty_seqlist(list) || sub < 0 || sub >= list->len)
	{
		printf("修改失败\n");
		return -1;
	}

	list->data[sub] = e;
	return 0;
}

/*
 * function:    按下表插入
 * @param [ in] 顺序表 下标 值
 * @param [out] 
 * @return      成功返回0失败返回-1
 */

int insert_sub(Seqlist *list, int sub, datatype e)
{
	if (list == NULL || full_seqlist(list) || sub < 0 || sub > list->len)
	{
		printf("插入失败\n");
		return -1;
	}

	for (int i = list->len - 1; i >= sub; i--)
	{
		list->data[i+1] = list->data[i];
	}
	list->data[sub] = e;
	list->len++;
	return 0;
}


/*
 * function:    按下表删除
 * @param [ in] 顺序表 下标 
 * * @param [out] 
 * @return      成功返回0失败返回-1
 */

int delete_sub(Seqlist *list, int sub)
{
	if (list == NULL || empty_seqlist(list) || sub < 0 || sub >= list->len)
	{
		printf("删除失败\n");
		return -1;
	}

	for (int i = sub; i <= list->len - 1; i++)
	{
		list->data[i] = list->data[i + 1];
	}
	list->len--;
	return 0;
}


/*
 * function:    按元素查找
 * @param [ in] 顺序表 元素
 * @param [out] 
 * @return      成功返回下标 失败返回-1
 */

int search_data(Seqlist *list, datatype key)
{
	if (list == NULL || empty_seqlist(list))
	{
		return -1;
	}

	for (int i = 0; i < list->len; i++)
	{
		if (list->data[i] == key)
		{
			return i;
		}
	}
	return -1;
}

/*
 * function:    按元素修改
 * @param [ in] 顺序表 查找的元素 修改的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int update_data(Seqlist *list, datatype key, datatype e)
{
	int sub = search_data(list, key);
	if (sub == -1)
	{
		return -1;
	}

	update_sub(list, sub, e);
	return 0;
}

/*
 * function:   	按元素删除
 * @param [ in] 顺序表 元素
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int delete_data(Seqlist *list, datatype key)
{
	int sub = search_data(list, key);
	if (sub == -1)
	{
		return -1;
	}

	delete_sub(list, sub);
	return 0;

}


/*
 * function:    按元素插入
 * @param [ in] 顺序表 插入位置的值 要插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */

int insert_data(Seqlist *list, datatype key, datatype e)
{
	int sub = search_data(list, key);
	if (sub == -1)
	{
		return -1;
	}

	insert_sub(list, sub, e);
	return 0;

}


/*
 * function:    相同元素仅留一个
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */

void remove_same(Seqlist *list)
{
	for (int i = 0; i < list->len; i++)
	{
		for(int j = i + 1; j < list->len; j++)
		{
			if (list->data[i] == list->data[j])
			{
				delete_sub(list, j);
				j--;
			}
		}
	}
}

/*
 * function:    顺序表冒泡降序排序
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */

void bubble_seqlist(Seqlist *list)
{
	for (int i = 0; i < list->len -1; i++)
	{
		int count=0;
		for (int j = 0; j < list->len - 1 - i; j++)
		{
			if (list->data[j] < list->data[j + 1])
			{
				datatype t = list->data[j];
				list->data[j] = list->data[j + 1];
				list->data[j + 1] = t;
				count++;
			}
		}
		if (count == 0)
		{
			return;
		}
	}
}

/*
 * function:    顺序表简单选择升序排序
 * @param [ in] 顺序表
 * @param [out] 
 * @return      无
 */

void simple_choose_seqlist(Seqlist *list)
{
	for (int i = 0; i < list->len - 1; i++)
	{
		datatype min = list->data[i];
		int mini = i;
		for (int j = i + 1; j < list->len; j++)
		{
			if (list->data[j] < min)
			{
				mini = j;
			}
		}

		if (mini != i)
		{
			datatype t = list->data[i];
			list->data[i] = list->data[mini];
			list->data[mini] = t;
		}
	}
	
}

/*
 * function:    两个有序顺序表合并成一个
 * @param [ in] 两个有序顺序表 一个空顺序表
 * @param [out] 
 * @return      无
 */

void combine_seqlist(Seqlist *lc, Seqlist *la, Seqlist *lb)
{
	int p = 0;
	int q = 0;
	while (p < la->len && q < lb->len)
	{
		if (la->data[p] <= lb->data[q])
		{
			lc->data[lc->len++] = la->data[p++];
		}
		else
		{
			lc->data[lc->len++] = lb->data[q++];
		}
	}
	
	while (p < la->len)
	{
		lc->data[lc->len++] = la->data[p++];
	}
	
	while (q < lb->len)
	{
		lc->data[lc->len++] = lb->data[q++];
	}

}

/*
 * function:    释放空间
 * @param [ in] 顺序表
 * @param [out] 
 * @return      NULL
 */

Seqlist *free_space(Seqlist *list)
{
	if (list == NULL)
	{
		return NULL;
	}

	free(list);
	list = NULL;
	return list;
}