1.24作业

最新推荐文章于 2024-09-04 18:39:13 发布

Demonlxl

最新推荐文章于 2024-09-04 18:39:13 发布

阅读量336

点赞数 10

文章标签：数据结构

本文链接：https://blog.csdn.net/Demonlxl/article/details/135829115

版权

作业要求：单链表按任意元素查找，单链表按任意元素修改，单链表按任意元素删除，单链表排序，单链表释放内存。

程序代码：

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

enum{FALSE=-1,SUCCESS};

typedef int datatype;

//定义节点结构体，节点：数据域 指针域
typedef struct Node
{
	//数据域：存储数据元素
	datatype  data;
	//指针域：存储下一个节点的地址
	struct Node *next;
}*Linklist;
Linklist create();
Linklist insert_head(Linklist head ,datatype element);
void output(Linklist head);
Linklist insert_rear(Linklist head ,datatype element);
Linklist delete_head(Linklist head);
Linklist delete_rear(Linklist head);
Linklist insert_pos(Linklist head,int pos,datatype element);
Linklist delete_pos(Linklist head,int pos);
void find_pos(Linklist head,int pos);
void change_pos(Linklist head,int pos,datatype element);    
Linklist rev(Linklist head);
void find_npos(Linklist head,int pos);
void bubble(Linklist head);
int find_element(Linklist head,datatype key);
void change_element(Linklist head,datatype key,datatype element);
int delete_element(Linklist head,datatype key);
#endif

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
	Linklist head=NULL;//定义单链表的头指针
	int n;
	datatype element;//插入的值
	printf("please input n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please input %d element:",i+1);
		scanf("%d",&element);
	//	head=insert_head(head,element);//头插
		head=insert_rear(head,element);//尾插
	}

	//单向链表遍历
	output(head);

	//单链表头删
	head=delete_head(head);
	output(head);


	//单链表尾删
	head=delete_rear(head);
	output(head);

	//单链表按任意位置插入
	int pos;
	printf("please input insert pos:");
	scanf("%d",&pos);
	printf("please input insert element:");
	scanf("%d",&element);
	head=insert_pos(head,pos,element);
	output(head);


	//单链表按任意位置删除
	printf("please input delete pos:");
	scanf("%d",&pos);
	head=delete_pos(head,pos);
	output(head);


	//单链表按任意位置查找
	printf("please input find pos:");
	scanf("%d",&pos);
	find_pos(head,pos);


	//单链表按任意位置修改
	printf("please input change pos:");
	scanf("%d",&pos);
	printf("please input change element:");
	scanf("%d",&element);
	change_pos(head,pos,element);
	output(head);



//单链表按任意元素查找

	datatype key;
	printf("please input key:");
	scanf("%d",&key);
	pos=find_element(head,key);
	printf("%d\n",pos);



//单链表按任意元素修改

	printf("please input which you want change:");
	scanf("%d",&key);
	printf("please input change element:");
	scanf("%d",&element);
	change_element(head,key,element);
	output(head);



//单链表按任意元素删除

	printf("please input which you want delete:");
	scanf("%d",&key);
	delete_element(head,key);
	output(head);

//单链表逆值

	head=rev(head);
	output(head);


//单链表查找倒数第n个

	printf("please input npos:");
	scanf("%d",&pos);
	find_npos(head,pos);


//单链表排序

	bubble(head);
	output(head);
	
//空间释放

	head=free_speace(head);

	return 0;

}

test.c

#include "head.h"
//堆区申请空间
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(NULL==s)
		return NULL;
	//成功初始化
	s->data=0;
	s->next=NULL;
	return s;
}
//头插
Linklist insert_head(Linklist head ,datatype element)
{
	//创建节点s
	Linklist s=create();
	s->data=element;
	//判断链表是否为空
	if(NULL==head)
	{
		head=s;
	}
	else
	{
		s->next=head;
		head=s;
	}
	return head;
}
//尾插
Linklist insert_rear(Linklist head ,datatype element)
{
	//创建节点s
	Linklist s=create();
	s->data=element;
	//判断链表是否为空
	if(NULL==head)
	{
		head=s;
	}
	else//存在多个节点
	{
		Linklist p=head;
		while(p->next!=NULL)
		{
			p=p->next;
		}
		p->next=s;
	}
	return head;
}

//单向链表遍历
void output(Linklist head)
{
	Linklist p=head;
	if(NULL==head)
	{
		puts("empty");
		return;
	}
	while(p!=NULL)
	{
		printf("%-5d",p->data);
		p=p->next;
	}
	puts("");
}
//单链表头删
Linklist delete_head(Linklist head)
{
	if(NULL==head)
		return head;
	else
	{
		Linklist del=head;
		head=head->next;
		free(del);
		return head;
	}
}
//单链表尾删
Linklist delete_rear(Linklist head)
{
	if(NULL==head)
		return head;
	else if(NULL==head->next)
	{
		free(head);
		head=NULL;
		return head;
	}
	else
	{
		Linklist del=head;
		while(del->next->next!=NULL)
		{
			del=del->next;
		}
		free(del->next);
		del->next=NULL;
		return head;
	}
}
//对于链表长度的计算
int length(Linklist head)
{
	int len=0;
	Linklist p=head;
	while(p)
	{
		p=p->next;
		len++;
	}
	return len;
}
//单链表按任意位置插入
Linklist insert_pos(Linklist head,int pos,datatype element)
{
	if(pos<1||pos>length(head)+1)
	{
		puts("pos error");
		return head;
	}
	Linklist s=create();
	s->data=element;
	if(pos==1)
	{
		head=insert_head(head,element);
		return head;
	}
	Linklist p=head;
	for(int i=1;i<pos-1;i++)
	{
		p=p->next;
	}
	s->next=p->next;
	p->next=s;
	return head;
}
//单链表按任意位置删除
Linklist delete_pos(Linklist head,int pos)
{
	if(pos<1||pos>length(head)||NULL==head)
	{
		puts("pos error");
		return head;
	}
	if(pos==1)
	{
		head=delete_head(head);
		return head;
	}
	Linklist p=head;
	for(int i=1;i<pos-1;i++)
	{
		p=p->next;
	}
	Linklist del=p->next;
	p->next=del->next;
	free(del);
	del=NULL;
	return head;
}

//单链表按任意位置查找
void find_pos(Linklist head,int pos)
{
	if(pos<1||pos>length(head)||NULL==head)
	{
		puts("pos error");
	}
	Linklist p=head;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	printf("%d\n",p->data);
}



//单链表按任意位置修改
void change_pos(Linklist head,int pos,datatype element)
{
	if(pos<1||pos>length(head)||NULL==head)
	{
		puts("pos error");
	}
	Linklist p=head;
	for(int i=1;i<pos;i++)
	{
		p=p->next;
	}
	p->data=element;
}



//单链表按任意元素查找
int find_element(Linklist head,datatype key)
{
	if(NULL==head)
	{
		puts("error");
	}
	Linklist p=head;
	int count=0;
	for(int i=0;i<length(head);i++)
	{
		count++;
		if(p->data==key)
		{
			return count;
		}
		p=p->next;
	}
	return FALSE;
}



//单链表按任意元素修改
void change_element(Linklist head,datatype key,datatype element)
{
	if(NULL==head)
	{
		puts("error");
	}
	Linklist p=head;
	for(int i=0;i<length(head);i++)
	{
		if(p->data==key)
		{
			p->data=element;
		}
		p=p->next;
	}
}


//单链表按任意元素删除

int delete_element(Linklist head,datatype key)
{
	if(NULL==head)
		return FALSE;
	int a=find_element(head,key);
	if(a==FALSE)
		return FALSE;
	else
	{
		delete_pos(head,a);
		return SUCCESS;
	}
}


//空间释放
Linklist free_speace(Linklist head)
{
	if(NULL==head)
		return head;
	Linklist p=head;
	while(p!=NULL)
	{
		p=delete_head(p);
	}
	head=NULL;
	return head;
}

//单链表逆值
Linklist rev(Linklist head)
{
	if(NULL==head)
		return head;
	Linklist p=head->next;
	head->next=NULL;
	while(p)
	{
		Linklist t=p;
		p=p->next;
		t->next=head;
		head=t;
	}
	return head;
}

//单链表查找倒数第n个
void find_npos(Linklist head,int pos)
{
	if(pos<1||pos>length(head)||NULL==head)
		return;
	Linklist p=head,q=head;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	while(p)
	{
		p=p->next;
		q=q->next;
	}
	printf("%d\n",q->data);
}


//单链表排序
void bubble(Linklist head)
{
	if(NULL==head)
		return;
//	int len=length(head);
	for(int i=1;i<length(head);i++)
	{
		Linklist p=head;
		for(int j=0;j<length(head)-i;j++)
		{
			if(p->data>p->next->data)
			{
				int t=p->data;
				p->data=p->next->data;
				p->next->data=t;
			}
			p=p->next;
		}
	}
}

单链表按任意元素查找运行结果：