2023.12.21 作业

练习

1.顺序表的操作

顺序表按元素删除(如果存在重复则只能删除第一个)

顺序表按元素修改

顺序表按元素查找

顺序表去重

顺序表排序

顺序表释放

代码部分：

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

//定义一个int别名，主要针对结构体中的data的数据类型，好改
typedef int datatype;

//定义数组元素个数
#define MAXSIZE 10

//创建结构体描述，顺序表，长度len必须初始化
typedef struct DataList
{
	datatype data[MAXSIZE];
	int len;
}dlist;
//创建枚举（每次只能使用一个成员）用来当做返回的值
enum A
{
	//会自增，成员逗号隔开
	FAIL=-1,
	SUCCESS
};

dlist* create();
int full(dlist *list);
int input(dlist *list,datatype n);
int empty(dlist *list);
int output(dlist *list);
int del_len(dlist *list);
void search_index(dlist *list,int index);
void change_index(dlist *list,int index,datatype num);
void insert_index(dlist *list,int index,datatype num);
void delete_index(dlist *list,int index);
int search_number(dlist *list,datatype num);
int change_number(dlist *list,datatype num,datatype cnum);
int delete_number(dlist *list,datatype num);
int repeat_number(dlist *list);
void bubble(dlist *list);
dlist * free_space(dlist *list);
#endif

main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	//输入n，循环输入n个数字，并写入结构体的data中
	int n;
	//申请堆区内存
	dlist *list=create();
	scanf("%d",&n);
	//定义结构体中int类型别名为datatype的变量
	datatype num;
	for(int i=0;i<n;i++)
	{
		printf("please enter %d num:",i+1);
		scanf("%d",&num);
		//判断数组data能否继续写入，不能写入原因：
		//顺序表长度为0(empty函数判断)，未创建表（list==NULL）
		//否则写入data，len长度+1
		int flag=input(list,num);
		if(flag==FAIL)
		{
			puts("FULL or empty");
			break;
		}
	}
	//输出顺序表内容
	output(list);
	//尾删：删除顺序表最后一个
	del_len(list);
	output(list);
	//搜索下表并输出该值
	int index;
	printf("please enter index:");
	scanf("%d",&index);
	search_index(list,index);

	//搜索下表所在位置的值，并重新复制(修改)
	datatype change_num;
	printf("please enter input change number:");
	scanf("%d",&change_num);
	change_index(list,index,change_num);
	output(list);
	
	//根据index插入数据
	datatype insert_num;
	printf("please enter index insert number:");
	scanf("%d",&insert_num);
	insert_index(list,index,insert_num);
	output(list);

	//根据index删除值
	int index_del;
	printf("please enter delete nuumber index:");
	scanf("%d",&index_del);
	delete_index(list,index_del);
	output(list);

	
	//按元素查找
	datatype searchnum;
	printf("please enter number to search:");
	scanf("%d",&searchnum);
	int flag=search_number(list,searchnum);
	if(flag==FAIL)
	{
		printf("查找对象不存在\n");
	}else{
		printf("查找元素 %d ,得到元素下标 %d\n",searchnum,flag);
	}

	//按元素修改
	datatype changenum,cnum;
	printf("please enter number to change:");
	scanf("%d",&changenum);
	printf("please enter change number to change:");
	scanf("%d",&cnum);
	int flag=change_number(list,changenum,cnum);
	if(flag==FAIL)
	{
		printf("查找对象不存在\n");
	}else{
		output(list);
	}

	//按元素删除
	datatype deletenum;
	printf("please enter number to delete:");
	scanf("%d",&deletenum);
	int flag=delete_number(list,deletenum);
	if(flag==FAIL)
	{
		printf("查找对象不存在\n");
	}else{
		output(list);
	}

	//按元素去重复
	repeat_number(list);
	output(list);

	//顺序表排序（降序）
	bubble(list);
	output(list);


	//s顺序表释放内存
	free_space(list);

	return 0;
}

test.c

#include "head.h"
//在堆区申请内存
dlist *create()
{
	//定义一个指针指向堆区的内存空间地址，并返回地址
	dlist *list=(dlist *)malloc(sizeof(dlist));
	//为了严谨，需要判断是否创建顺序空表或者申请了内存
	if(NULL==list)
		return list;
	//给成员初始化，顺序表长度len必须初始化
	memset(list->data,0,sizeof(list->data));
	list->len=0;
	return list;
}
//判断顺序表中内容是否超出
int full(dlist *list)
{
	return list->len==MAXSIZE?FAIL:SUCCESS;
}
//判断顺序表是否为空或者是否创建，否则存入值，并增加长度len+1
//尾插
int input(dlist *list,datatype n)
{
	if(NULL==list || full(list))
	{
		return FAIL;
	}
	list->data[list->len]=n;
	list->len++;
	return SUCCESS;
}
//判断顺序表长度是否为0，有没有内容
int empty(dlist *list)
{
	return list->len==0?FAIL:SUCCESS;
}
//输出顺序表中的内容
int output(dlist *list)
{
	//严谨判断是否为空或者有没有内容
	if(NULL==list || empty(list))
	{
		return FAIL;
	}
	//循环输出表中的内容
	for(int i=0;i<list->len;i++)
	{
		printf("%d\t",list->data[i]);
	}
	puts("");
	return SUCCESS;
}
//尾删
//不能直接删除，要么设置值为空(没意义)，让len-1，让长度减1，达到删除效果
int del_len(dlist *list)
{
	if(NULL==list || empty(list))
	{
		return FAIL;
	}
	list->len--;
	return SUCCESS;
}
//根据下表查找表中的值
void search_index(dlist *list,int index)
{
	//需要判断接收的下表index是否满足条件，严谨判断是否为空或者有没有内容
	if(NULL==list || empty(list) || index<0 || index >=list->len)
	{
		return;
	}
	//输出下表为index的表中的值
	printf("search of the index number is %d\n:",list->data[index]);
}

//修改内容
void change_index(dlist *list,int index,datatype change_num)
{
	if(NULL==list || empty(list) || index>=list->len || index<0)
	{
		return;
	}
	list->data[index]=change_num;
}

//插入值，要判断表中是否还有空，否则插入后其他元素往后退1,
//index可以从第1个开始插入，也可以插入最后1个，但是不能和最后一个之间有空
//顺序表 逻辑相邻，物理相邻
void insert_index(dlist *list,int index,datatype insert_num)
{
	if(NULL==list || full(list) || index<0 || index>list->len)
		return;
	for(int i=list->len-1;i>=index;i--)
	{
		list->data[i+1]=list->data[i];
	}
	list->data[index]=insert_num;
	list->len++;
}

//删除index 的值，除去正常判断是否和法外，还需要注意
//删除index的值，所有后面的元素要往前移动，len长度要-1
//达到删除效果，可以把当前index+1的值赋给index的值
void delete_index(dlist *list,int index)
{
	if(NULL==list || empty(list) || index<0 || index>=list->len)
		return;
	for(int i=index;i<list->len;i++)
	{
		list->data[i]=list->data[i+1];
	}
	list->len--;
}

//按元素查找，判断查找的元素是否存在，类型是否一致，返回下标
int search_number(dlist *list,datatype num)
{
	if(NULL==list || empty(list))
		return FAIL;

	for(int i=0;i<list->len;i++)
	{
		if(num==list->data[i])
		{
			return i;
		}
		if(i==list->len && num!=list->data[i])
		{
			return FAIL;
		}
	}
}

//按元素修改，注意判断条件
int change_number(dlist *list,datatype num,datatype cnum)
{
	if(NULL==list || empty(list))
	{
		return FAIL;
	}
	for(int i=0;i<(list->len);i++)
	{
		if(num==list->data[i])
		{
			datatype old_number=list->data[i];
			list->data[i]=cnum;
			printf("%d 修改为：%d\n",old_number,list->data[i]);
			return i;
		}
		if(num!=list->data[i] && i==list->len-1)
		{
			return FAIL;
		}
	}
}

//按元素删除，如果有重复，只能删除第一个,返回下标
int delete_number(dlist *list,datatype num)
{
	if(NULL==list || empty(list))
	{
		return FAIL;
	}
	for(int i=0;i<list->len;i++)
	{
		if(num==list->data[i])
		{
			for(int j=i;j<list->len;j++)
			{
				list->data[j]=list->data[j+1];
			}
			list->len--;
			return i;
		}
		if(num!=list->data[i] && i==list->len)
		{
			return FAIL;
		}
	}
}

//按元素去重复，和简单选择排序思维相似
int repeat_number(dlist *list)
{
	if(NULL==list || empty(list))
		return FAIL;
	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_index(list,j);
				j--;
			}
		}
	}
	
}

//顺序表降序排列 冒泡
void bubble(dlist *list)
{
	for(int i=1;i<list->len;i++)
	{
		for(int j=0;j<list->len-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;
			}
		}
	}
}

//顺序表释放内存
dlist *free_space(dlist *list)
{
	if(NULL==list || empty(list))
	{
		puts("释放内存失败");
		return NULL;
	}
	free(list);
	list=NULL;
	puts("释放内存成功");
}