数据结构_Day03

作业

1> 顺序表按元素删除
思路：参数【顺序表 删除的值key】
1.根据删除的元素得到下标
2.根据下标实现【按下标删除】

2>顺序表排序【类似数组排序】
比较：if( list->data[j] > list->data[j+1])

main.c

#include"head.h"

int main(int argc, const char *argv[])
{
	int n, i;
	datatype e;
	seqlist * p = create();  //在堆区申请一个顺序表的空间
	datatype data, data_new;
	printf("请输入您要插入的数量：");
	scanf(" %d", &n);
	for(i = 0; i<n; i++)
	{
		printf("请输入您要插入的数据：");
		scanf(" %d", &e);
		insert_rear(p, e);
	}
	output(p);

	//查找数据，按下标
	printf("请输入要查找的元素下标：");
	int sub;
	scanf(" %d", &sub);
	search_sub(p, sub);

	//修改数据，按下标
	printf("请输入要修改的元素下标：");
	scanf(" %d", &sub);
	printf("请输入数据：");
	scanf(" %d", &e);
	update_sub(p, sub, e);

	//插入数据，按下标
	printf("请输入要插入的元素下标：");
	scanf(" %d", &sub);
	printf("请输入数据：");
	scanf(" %d", &e);
	insert_sub(p, sub, e);
	output(p);

	//删除数据，按下标
	printf("请输入要删除的元素下标：");
	scanf(" %d", &sub);
	delete_sub(p, sub);
	output(p);

	//查找数据，按元素
	printf("请输入要查找的元素值：");
	scanf(" %d", &data);
	sub = search_data(p, data); 
	if( sub == -1 )
	{
		printf("没有找到该元素！\n");
	}
	else
		printf("该元素的下标为%d\n", sub);

	//修改数据，按元素
	printf("请输入要修改的元素值：");
	scanf(" %d", &data);
	printf("请输入新的元素值：");
	scanf(" %d", &data_new);
	if(update_data(p, data, data_new))
		printf("修改失败\n");
	else
	{
		output(p);
	}
	
	//顺序表排序
	if(!sort_list_bubble(p))
	{
		output(p);
	}

	//释放堆区
	free(p);
	p = NULL;
	if(p == NULL)
		printf("空间释放完成。\n");
	return 0;
}

fun.c

#include"head.h"

/*
 * function:    在堆区申请一个顺序表的空间
 * @return      成功返回地址，失败返回NULL 
 */
seqlist *create()
{
	seqlist *list = (seqlist *)malloc(sizeof(seqlist));
	if(list == NULL)
		return NULL;
	list->len = 0;
	return list;
}
/*
 * function:    判断线性表是否已满
 * @param [list] 顺序表指针
 * @return      已满返回-1，未满返回0
 */
int full_seqlist(seqlist * list)
{
	if(list->len == MAXSIZE)
	{
		printf("顺序表已满！\n");
		return -1;
		
	}
	return 0;
}
/*
 * function:    判断线性表是否为空
 * @param [list] 顺序表指针
 * @return      已空返回-1，未空返回0
 */
int empty_seqlist(seqlist * list)
{
	if(list->len == 0)
	{
		printf("顺序表为空！\n");
		return -1;
	}
	return 0;
}
/*
 * function:    在尾部插入
 * @param [list] 顺序表指针
 * @param [e] 要插入的数值
 * @return      成功返回0，失败-1
 */
int insert_rear(seqlist * list, datatype e)
{
	if(full_seqlist(list))
		return -1;
	list->data[list->len] = e;
	list->len++;
	return 0;
}
/*
 * function:    输出线性表
 * @param [list] 顺序表指针
 * @return      
 */
void output(seqlist * list)
{
	if(empty_seqlist( list ))
	{
		printf("当前的顺序表为空！\n");
	}
	printf("当前的顺序表为：");
	for(int i = 0; i<list->len ;i++)
	{
		printf("%d\t", list->data[i]);
	}
	printf("\n");
}
/*
 * function:    顺序表尾删
 * @param [list] 顺序表指针
 * @return      成功返回0， 失败返回-1
 */
int delete_rear(seqlist *list)
{
	if((empty_seqlist))
	{
		printf("顺序表为空\n");
		return -1;
	}
	list->len--;
	return 0;
}
/*
 * function:    顺序表按下标查找
 * @param [list] 顺序表指针
 * @param [sub] 要查找的下标
 * @return      成功返回下标位置的数值， 失败返回-1
 */
datatype search_sub(seqlist * list, int sub)
{
	if(empty_seqlist(list) || sub<0 || sub > list->len)
	{
		printf("顺序表查找失败\n");
		return -1;
	}
	printf("查找的数据为%d\n", list->data[sub]);
	return list->data[sub];
}
/*
 * function:    修改数据
 * @param [list] 顺序表指针
 * @param [sub] 要修改的元素的下标
 * @param [e] 新值
 * @return      成功返回0，失败返回-1
 *
 */
int update_sub(seqlist * list, int sub, datatype e)
{
	if(empty_seqlist(list) || sub<0 || sub > list->len)
	{
		printf("顺序表修改失败\n");
		return -1;
	}
	list->data[sub] = e;
	printf("顺序表修改成功，下标为 %d 的元素已修改为 %d\n", sub, list->data[sub]);
	output(list);
	return 0;
}
/*
 * function:    按下标插入
 * @param [list] 顺序表指针
 * @param [sub] 要插入的位置的下标
 * @param [e] 要插入的值
 * @return      成功返回0，失败返回-1
 */
int insert_sub(seqlist * list, int sub, datatype e)
{
	if(full_seqlist(list) || sub < 0 || sub > list->len)
	{
		printf("插入失败\n");
		return -1;
	}
	for(int i = list->len; i>sub; i--)
	{
		list->data[i] = list->data[i-1];
	}
	list->data[sub] = e;
	list->len++;
	printf("插入成功\n");
	return 0;
}
/*
 * function:    按下标删除
 * @param [list] 顺序表指针
 * @param [sub] 要删除的元素下标
 * @return      成功返回0，失败返回-1
 */
int delete_sub(seqlist * list, int sub)
{
	if(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--;
	printf("删除成功\n");
	return 0;
}

/*
 * function:    按元素查找
 * @param [list] 顺序表指针
 * @param [data] 要查找的数值
 * @return      成功返回下标，失败返回-1
 */
int search_data(seqlist * list, datatype data)
{
	if(empty_seqlist( list ))
	{
		return -1;
	}
	for(int i = 0; i<list->len; i++)
	{
		if(list->data[i] == data)
		{
			return i;
		}
	}
	printf("未找到该元素\n");
	return -1;
}
#if 0
/*
 * function:	找到相同的值进行修改(全局更改)
 * @param [list] 顺序表指针，，新的数值
 * @param [data] 要修改的数值
 * @param [data_new] 新的数值
 * @return      成功返回0，失败返回-1
 */
int update_data(seqlist * list, datatype data, datatype data_new)
{
	if(list->len == 0)
		return -1;
	for(int i = 0; i<list->len; i++)
	{
		if(list->data[i] == data)
		{
			list->data[i] = data_new;
		}
	}
	return 0;
}
#endif

#if 1
/*
 * function:	找到相同的值进行修改(只更改第一个)
 * @param [list] 顺序表指针
 * @param [data] 要修改的数值
 * @param [data_new] 新的数值
 * @return      成功返回0，失败返回-1
 */
int update_data(seqlist * list, datatype data, datatype data_new)
{
	int sub = search_data(list, data);
	if(sub == -1)
	{
		return -1;
		printf("修改失败\n");
	}
	update_sub(list, sub, data_new);
	return 0;
}
#endif
/*
 * function:	顺序表排序
 * @param [list] 顺序表指针
 * @return      成功返回0，失败返回-1
 */
int sort_list_bubble(seqlist * list)
{
	datatype temp;
	if(empty_seqlist( list ))
	{	
		return -1;
	}
	for(int i = 0; i<list->len-1; i++) //外层控制循环次数
	{
		for(int j = 0; j<list->len-1-i; j++) //内层控制比较和互换
		{
			if( list->data[j] > list->data[j+1])
			{
				temp = list->data[j];list->data[j] = list->data[j+1];list->data[j+1] = temp;
			
			}
		}
	}
	printf("排序完成,");
	return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXSIZE 7

typedef datatype; //顺序表数据类型
typedef struct  //结构体名可以为空
{
	datatype data[MAXSIZE];  //长度为  的数据元素
	int len;
}seqlist;  //结构体类型名

//在堆区申请一个顺序表的空间
seqlist *create();
int full_seqlist(seqlist * list);
int insert_rear(seqlist * list, datatype e);

int delete_rear(seqlist * list);
void output(seqlist * list);

int search_sub(seqlist * list, int sub);

int update_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 data);
int update_data(seqlist * list, datatype data, datatype data_new);
int sort_list_bubble(seqlist * list);
#endif