2023.04.19 数据结构day3

逆鳞2233

已于 2023-04-19 19:35:04 修改

阅读量60

点赞数

文章标签：数据结构

于 2023-04-19 19:14:08 首次发布

本文链接：https://blog.csdn.net/qq_42328433/article/details/130250217

版权

1.顺序表特定元素删除

//顺序表元素删除
int SeqlistDeleteByData(Seqlist *p,datatype key)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		printf("删除失败\n");
		return -1;
	}
	int ret = SeqlistSearchByData(p,key);
	if(ret == -1)
	{
		printf("删除失败\n");
		return -1;
	}
	SeqlistDeleteBySub(p,ret);
	return 0;
}

2.在顺序表特定元素后插入数据

//顺序表在元素后插入
int SeqlistInsertByData(Seqlist *p,datatype key,datatype e)
{
	if(p==NULL || SeqlistFull(p))
	{
		printf("插入失败\n");
		return -1;
	}
	int ret = SeqlistSearchByData(p,key);
	if(ret == -1)
	{
		printf("插入失败\n");
		return -1;
	}
	SeqlistInsertBySub(p,ret+1,e);
	return 0;
}

3.顺序表排序

//顺序表排序
int SeqlistBubbleSort(Seqlist *p)
{
	if(p== NULL || SeqlistEmpty(p))
	{
		printf("排序失败\n");
		return -1;
	}
	for(int i=1;i<p->len;i++)
	{
		int count=0;
		for(int j=0;j<p->len-i;j++)
		{
			if(p->data[j] > p->data[j+1])
			{
				datatype temp = p->data[j];
				p->data[j] = p->data[j+1];
				p->data[j+1] = temp;
				count++;
			}
		}
		if(count==0)
			break;
	}
	return 0;
}

1,2,3的运行结果：

zzy@zzy-vm:~/hqrj/struct/day3/11$ gcc *.c
zzy@zzy-vm:~/hqrj/struct/day3/11$ ./a.out
请输入插入个数:5
请输入插入的数:25
请输入插入的数:39
请输入插入的数:74
请输入插入的数:48
请输入插入的数:3
25	39	74	48	3	
--------------------------------
请输入查找元素:39
请输入插入数据:45
25	39	45	74	48	3	
删除后的顺序表为:
25	39	74	48	3	
--------------------------------
排序后的数据为:
3	25	39	48	74

4.顺序表合并

//顺序表有序合并
void SeqlistCombine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
	//la,lb待合并顺序表，lc为合并后顺序表
	int p=0,q=0,r=0;   //分别代表表la,lb,lc的下标
	while(p<la->len && q<lb->len)
	{
		if(la->data[p] < lb->data[q])
		{
			lc->data[r] = la->data[p];
			p++;
			r++;
			lc->len++;
		}
		else
		{
			lc->data[r] = lb->data[q];
			q++;
			r++;
			lc->len++;
		}
	}
	while(p<la->len)
	{
		lc->data[r] = la->data[p];
		p++;
		r++;
		lc->len++;
	}
	while(q<lb->len)
	{
		lc->data[r] = lb->data[q];
		q++;
		r++;
		lc->len++;
	}
}

运行结果

zzy@zzy-vm:~/hqrj/struct/day3/11$ gcc *.c
zzy@zzy-vm:~/hqrj/struct/day3/11$ ./a.out 
请输入插入个数:5
请输入插入的数:15
请输入插入的数:52
请输入插入的数:63
请输入插入的数:35
请输入插入的数:18
15	52	63	35	18	
15	18	35	52	63	
--------------------------------------
请输入插入个数:7
请输入插入的数:18
请输入插入的数:96
请输入插入的数:100
请输入插入的数:84
请输入插入的数:2
请输入插入的数:1
请输入插入的数:36
18	96	100	84	2	1	36	
1	2	18	36	84	96	100	
--------------------------------------
1	2	15	18	18	35	36	52	63	84	96	100

5.顺序表空间释放

//顺序表空间释放
Seqlist *FreeSpace(Seqlist *p)
{
	if(p==NULL)
		return NULL;
	free(p);
	p=NULL;
	return p;
}

附录：顺序表完整代码

1.头文件head.h

#define __HEAD_H__

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

#define MAXSIZE 20

typedef int datatype;

typedef struct
{
	//数据元素
	datatype data[MAXSIZE];
	//顺序表长度
	int len;
} Seqlist;

//顺序表创建
Seqlist *CreateSpace();

//顺序表判满
int SeqlistFull(Seqlist *p);

//顺序表判空
int SeqlistEmpty(Seqlist *p);

//顺序表尾插
int InsertByRear(Seqlist *p,datatype data);

//顺序表尾删
int DeleteByRear(Seqlist *p);

//顺序表遍历输出
int SeqlistOutput(Seqlist *p);

//顺序表下标查找
int SeqlistSearchBySub(Seqlist *p,int sub);

//顺序表下标修改
int SeqlistUpdateBySub(Seqlist *p,int sub,datatype e);

//顺序表下标插入
int SeqlistInsertBySub(Seqlist *p,int sub,datatype e);

//顺序表下标删除
int SeqlistDeleteBySub(Seqlist *p,int sub);

//顺序表元素查找
int SeqlistSearchByData(Seqlist *p,datatype key);

//顺序表元素修改
int SeqlistUpdateByData(Seqlist *p,datatype key,datatype e);

//顺序表元素删除
int SeqlistDeleteByData(Seqlist *p,datatype key);

//顺序表在元素后插入
int SeqlistInsertByData(Seqlist *p,datatype key,datatype e);

//顺序表去重
void SeqlistDeleteSame(Seqlist *p);

//顺序表排序
int SeqlistBubbleSort(Seqlist *p);

//顺序表有序合并
void SeqlistCombine(Seqlist *la,Seqlist *lb,Seqlist *lc);

//顺序表空间释放
Seqlist *FreeSpace(Seqlist *p);

#endif

2.功能函数test.c

#include "head.h"

//顺序表创建
Seqlist *CreateSpace()
{
	Seqlist *p = (Seqlist *)malloc(sizeof(Seqlist));
	if(p==NULL)
		return NULL;
	p->len = 0;
	return p;
}

//判断顺序表满  满返回-1   未满返回0
int SeqlistFull(Seqlist *p)
{
	if(p->len == MAXSIZE)
		return -1;
	return 0;
}

//判断顺序表空  空返回-1  非空返回0
int SeqlistEmpty(Seqlist *p)
{
	return p->len==0?-1:0;
}

//顺序表尾插
int InsertByRear(Seqlist *p, datatype e)
{
	if(p==NULL || SeqlistFull(p))
	{
		printf("插入失败\n");
		return -1;
	}
	p->data[p->len++] = e;
	return 0;
}

//顺序表尾删
int DeleteByRear(Seqlist *p)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		printf("删除失败\n");
		return -1;
	}
	p->len--;
	return 0;
}

//顺序表遍历输出
int SeqlistOutput(Seqlist *p)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		printf("遍历失败\n");
		return -1;
	}
	for(int i=0;i<p->len;i++)
		printf("%d\t",p->data[i]);
	putchar(10);
	return 0;
}

//顺序表下标查找
int SeqlistSearchBySub(Seqlist *p,int sub)
{
	if(p==NULL || SeqlistEmpty(p) || sub<0 || sub>=p->len)
	{
		printf("查找失败\n");
		return -1;
	}
	printf("查找的元素为%d\n",p->data[sub]);
	return 0;
}

//顺序表下标修改
int SeqlistUpdateBySub(Seqlist *p,int sub,datatype e)
{
	if(p==NULL || SeqlistEmpty(p) || sub<0 || sub>=p->len)
	{
		printf("修改失败\n");
		return -1;
	}
	p->data[sub] = e;
	return 0;
}

//顺序表下标插入
int SeqlistInsertBySub(Seqlist *p,int sub,datatype e)
{
	if(p==NULL || SeqlistFull(p) || sub<0 || sub>p->len)
	{
		printf("插入失败\n");
		return -1;
	}
	for(int i=p->len-1;i>=sub;i--)
	{
		p->data[i+1] = p->data[i];
	}
	p->data[sub] = e;
	p->len++;
	return 0;
}

//顺序表下标删除
int SeqlistDeleteBySub(Seqlist *p,int sub)
{
	if(p==NULL || SeqlistEmpty(p) || sub<0 || sub>=p->len)
	{
		printf("删除失败\n");
		return -1;
	}
	for(int i=sub;i<p->len-1;i++)
	{
		p->data[i] = p->data[i+1];
	}
	p->len--;
	return 0;
}

//顺序表元素查找
int SeqlistSearchByData(Seqlist *p,datatype key)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		return -1;
	}
	for(int i=0;i<p->len;i++)
	{
		if(p->data[i] == key)
			return i;
	}
	return -1;
}

//顺序表元素修改
int SeqlistUpdateByData(Seqlist *p,datatype key,datatype e)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		printf("修改失败\n");
		return -1;
	}
	int ret = SeqlistSearchByData(p,key);
	if(ret == -1)
	{
		printf("修改失败\n");
		return -1;
	}
	SeqlistUpdateBySub(p,ret,e);
	return 0;
}

//顺序表元素删除
int SeqlistDeleteByData(Seqlist *p,datatype key)
{
	if(p==NULL || SeqlistEmpty(p))
	{
		printf("删除失败\n");
		return -1;
	}
	int ret = SeqlistSearchByData(p,key);
	if(ret == -1)
	{
		printf("删除失败\n");
		return -1;
	}
	SeqlistDeleteBySub(p,ret);
	return 0;
}

//顺序表在元素后插入
int SeqlistInsertByData(Seqlist *p,datatype key,datatype e)
{
	if(p==NULL || SeqlistFull(p))
	{
		printf("插入失败\n");
		return -1;
	}
	int ret = SeqlistSearchByData(p,key);
	if(ret == -1)
	{
		printf("插入失败\n");
		return -1;
	}
	SeqlistInsertBySub(p,ret+1,e);
	return 0;
}

//顺序表去重
void SeqlistDeleteSame(Seqlist *p)
{
	for(int i=0;i<p->len-1;i++)
	{
		for(int j=i+1;j<p->len;j++)
		{
			if(p->data[i] == p->data[j])
			{
				SeqlistDeleteBySub(p,j);
				j--;
			}
		}
	}
}

//顺序表排序
int SeqlistBubbleSort(Seqlist *p)
{
	if(p== NULL || SeqlistEmpty(p))
	{
		printf("排序失败\n");
		return -1;
	}
	for(int i=1;i<p->len;i++)
	{
		int count=0;
		for(int j=0;j<p->len-i;j++)
		{
			if(p->data[j] > p->data[j+1])
			{
				datatype temp = p->data[j];
				p->data[j] = p->data[j+1];
				p->data[j+1] = temp;
				count++;
			}
		}
		if(count==0)
			break;
	}
	return 0;
}

//顺序表有序合并
void SeqlistCombine(Seqlist *la,Seqlist *lb,Seqlist *lc)
{
	//la,lb待合并顺序表，lc为合并后顺序表
	int p=0,q=0,r=0;   //分别代表表la,lb,lc的下标
	while(p<la->len && q<lb->len)
	{
		if(la->data[p] < lb->data[q])
		{
			lc->data[r] = la->data[p];
			p++;
			r++;
			lc->len++;
		}
		else
		{
			lc->data[r] = lb->data[q];
			q++;
			r++;
			lc->len++;
		}
	}
	while(p<la->len)
	{
		lc->data[r] = la->data[p];
		p++;
		r++;
		lc->len++;
	}
	while(q<lb->len)
	{
		lc->data[r] = lb->data[q];
		q++;
		r++;
		lc->len++;
	}
}

//顺序表空间释放
Seqlist *FreeSpace(Seqlist *p)
{
	if(p==NULL)
		return NULL;
	free(p);
	p=NULL;
	return p;
}

3.主函数main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	Seqlist *p = CreateSpace();
	int n,sub;
	datatype e,key;
	printf("请输入插入个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入插入的数:");
		scanf("%d",&e);
		InsertByRear(p,e);
	}
	SeqlistOutput(p);

	/*
	printf("--------------------------------\n");
	printf("请输入查找元素:");
	scanf("%d",&key);
	printf("请输入插入数据:");
	scanf("%d",&e);
	SeqlistInsertByData(p,key,e);
	SeqlistOutput(p);
    printf("删除后的顺序表为:\n");
	SeqlistDeleteByData(p,e);
	SeqlistOutput(p);
	printf("--------------------------------\n");
	printf("排序后的数据为:\n");
	*/

	SeqlistBubbleSort(p);
	SeqlistOutput(p);
	printf("--------------------------------------\n");

	//输入一个新顺序表并排序
	Seqlist *p1 = CreateSpace();
	printf("请输入插入个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入插入的数:");
		scanf("%d",&e);
		InsertByRear(p1,e);
	}
	SeqlistOutput(p1);
	SeqlistBubbleSort(p1);
	SeqlistOutput(p1);
	printf("--------------------------------------\n");

	//合并两个顺序表
	Seqlist *p2 = CreateSpace();
	SeqlistCombine(p,p1,p2);
	SeqlistOutput(p2);

	p=FreeSpace(p);
	p1=FreeSpace(p1);
	p2=FreeSpace(p2);
	return 0;
}