数据结构DAY3

 顺序表合并

 选择升序排序

 按元素删除

 按元素修改

 顺序表去重

 顺序表冒泡降序

 按元素插入

 头文件

#ifndef __1HEAD_H__
#define __1HEAD_H__


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

//定义线性表长度
#define MAXSIZE 20
typedef int datatype;//表示数据元素的类型
//定义顺序表
typedef struct
{
	//数据元素
	datatype data[MAXSIZE];
	//顺序表长度
	int len;
}Seqlist,*seq_t;

Seqlist *create_seqlist();
int insert_rear(datatype e,Seqlist *list);
void output(Seqlist *list);
int delete_rear(Seqlist *list);
int search_sub(Seqlist *list,int sub);
int exchange_sub(Seqlist *list,int sub,datatype 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 insert_data(Seqlist *list,datatype key,datatype e);
int exchange_data(Seqlist *list,datatype key,datatype e);
int delete_data(Seqlist *list, datatype key);
void combine(Seqlist *la,Seqlist *lb,Seqlist *lc);
void dedup(Seqlist *la);
void Sort(Seqlist *list);
void Select_sort(Seqlist *list);
Seqlist *free_space(Seqlist *list);








#endif

#include "1head.h"


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


Seqlist *create_seqlist()
{
	Seqlist *list = (Seqlist *)malloc(sizeof(Seqlist));
	if (NULL == list)
		return NULL;
	//为数组元素初始化清0，可以不写
	//后面元素写入时会将数据覆盖
	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(datatype e,Seqlist *list)
{
	//判断顺序表是否存在
	//判断顺序表是否满了
	//if (NULL == list || list->len == MAXSIZE)
	if (NULL == list || full_seqlist(list))
		return -1;
	list->data[list->len] = e;
	list->len++;
	return 0;
}

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

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

/*
 * function:    循环输出顺序表
 * @param [ in] 
 * @param [out] 顺序表
 * @return      
 */

void output(Seqlist *list)
{
	//判断顺序表是否存在
	//判断顺序表是否为空
	if (NULL == list || empty(list))
		return;//结束
	for (int i = 0; i < list->len; i++)
	{
		printf("%d\t",list->data[i]);
	}
	puts("");
}

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

int delete_rear(Seqlist *list)
{
	if (NULL == list || empty(list))
		return -1;
	list->len--;
}

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

int search_sub(Seqlist *list,int sub)
{
	if (NULL == list || empty(list) || sub < 0 || sub >= list->len)
	{	puts("查找失败");
		return -1;
	}
	return list->data[sub];
}

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

int exchange_sub(Seqlist *list,int sub,datatype e)
{
	if (NULL == list || empty(list) || sub < 0 || sub >= list->len)
	{	puts("查找失败");
		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 (NULL == list || full_seqlist(list) || sub < 0 || sub > list->len)
	{
		puts("插入失败");
		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 (NULL == list || empty(list) || sub < 0 || sub >= list->len)
	{	puts("删除失败");
		return -1;
	}
	for (int i = sub; i < list->len; 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(NULL == list || empty(list))
		return -1;
	for (int i = 0; i < list->len; i++)
	{
		if(key == list->data[i])
			return i;
	}
	return -1;
}


/*
 * 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)
	{ 	puts("失败");
		return -1;
	}
	insert_sub(list,sub,e);
	return 0;
}

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

int exchange_data(Seqlist *list,datatype key,datatype e)
{
	int sub = search_data(list,key);
	if(sub == -1)
	{ 	puts("失败");
		return -1;
	}
	exchange_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)
	{
		puts("失败");
		return -1;
	}
	delete_sub(list,sub);
	return 0;
}

/*
 * function:    顺序表合并
 * @param [ in] 
 * @param [out] 三个顺序表
 * @return      无
 */

void combine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
	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      无
 */
	
void dedup(Seqlist *la)
{
	int i,j;
	for (i = 0; i <la->len-1; i++)
	{
		for (j = i+1; j < la->len; j++)
		{
			if (la->data[i] == la->data[j])
			{
				delete_sub(la,j);
				j--;
			}
		}
	}
}

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

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

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

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

/*
 * function:    顺序表释放空间
 * @param [ in] 
 * @param [out] 顺序表
 * @return      返回顺序表地址
 */

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

#include "1head.h"


int main(int argc, const char *argv[])
{
/*	Seqlist *list = create_seqlist();
	//尾插
	int n;
	printf("请输入插入的个数：");
	scanf("%d",&n);
	datatype e;
	for (int i = 0; i < n; i++)
	{
		printf("请输入元素：");
		scanf("%d",&e);
		insert_rear(e,list);
	}
	output(list);                         
*/
/*	delete_rear(list);
	delete_rear(list);
	delete_rear(list);
	printf("尾删后的元素为：\n");
	output(list);
	//按下标查找
	int sub = 0;
	printf("请输入查找的下标：");
	scanf("%d",&sub);
	int a = search_sub(list,sub);
	if (a!=-1)
		printf("查找的下标对应元素为：%d\n",a);
*/ 	//按下标修改
/*	int sub = 0;
	printf("请输入修改的下标：");
	scanf("%d",&sub);
	printf("请输入修改的值：");
	scanf("%d",&e);
	int	a = exchange_sub(list,sub,e);
	if (a!=-1)
		output(list);
*/	//按下标插入
/*
 	int sub = 0;
	printf("请输入插入的下标：");
	scanf("%d",&sub);
	printf("请输入插入的值：");
	scanf("%d",&e);
	int	a = insert_sub(list,sub,e);
	if (a!=-1)
		output(list);
*/
	//按下标删除
/*	int sub = 0;
	printf("请输入删除的下标：");
	scanf("%d",&sub);
	int	a = delete_sub(list,sub);
	if (a!=-1)
		output(list);
*/
	//按元素查找
/*	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&key);
	int sub = search_data(list,key);
	if(sub == -1)
		puts("查找失败");
	else
		printf("查找元素%d对应下标为：%d\n",key,sub);
*/
	//按元素插入
/*	
 	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&key);
	printf("请输入插入的元素：");
	scanf("%d",&e);
	insert_data(list,key,e);
	output(list);
*/

	//按元素修改
/* 	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&key);
	printf("请输入修改的元素：");
	scanf("%d",&e);
	exchange_data(list,key,e);
	output(list);
*/
	//按元素删除
/* 	datatype key = 0;
	printf("请输入查找的元素：");
	scanf("%d",&key);
	delete_data(list,key);
	output(list);
*/	
	//顺序表合并
/*	Seqlist la = {11,11,13,15,16};
	la.len = 5;
	Seqlist lb = {12,13,15,78,99,101};
	lb.len = 6;
	Seqlist lc;
	lc.len = 0;
	combine(&la,&lb,&lc);
	output(&lc);
*/	
	//顺序表去重
	Seqlist la = {12,23,43,12,13,23,12,56,23,78,43,12};
	la.len = 12;
	printf("去重前元素：\n");
	output(&la);
	dedup(&la);
	printf("去重后元素：\n");
	output(&la);

	//顺序表冒泡降序排序
/*	Seqlist *list = create_seqlist();
	//尾插
	int n;
	printf("请输入插入的个数：");
	scanf("%d",&n);
	datatype e;
	for (int i = 0; i < n; i++)
	{
		printf("请输入元素：");
		scanf("%d",&e);
		insert_rear(e,list);
	}
	output(list); 
	Sort(list);
	printf("冒泡降序后元素：\n");
	output(list);                         
*/
	//顺序表选择升序排序
/*	Seqlist *list = create_seqlist();
	//尾插
	int n;
	printf("请输入插入的个数：");
	scanf("%d",&n);
	datatype e;
	for (int i = 0; i < n; i++)
	{
		printf("请输入元素：");
		scanf("%d",&e);
		insert_rear(e,list);
	}
	output(list); 
	Select_sort(list);
	printf("选择升序后元素：\n");
	output(list);                         
*/

//	list = free_space(list);
	return 0;
}