Linux作业

2023-4-20作业补

单向链表按位置修改数值

单向链表按元素修改数值

单向链表按元素删除数值

单向链表在给定元素前插入数值

单向链表的排序

单向链表空间释放

#ifndef __STRUCTH3_H__    //选择注释函数头
#define __STRUCTH3_H__    //选择注释函数头

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

typedef int datatype;  //类型重定义 将int类型重命名为 datatype

//定义结构体
typedef struct Node     //类型重定义结构体
{
	union        //共用体定义
	{
		int len;    //链表头节点Node的数据域
		datatype data;  //链表普通节点Node的数据域
	};
	struct Node *next;  //链表Node节点的指针域
}*linklist;



linklist create_head(int flag);   //被调函数声明
linklist create_node();
int insert_head(linklist L,datatype e);
void output(linklist L);
int update_pos(linklist L,int pos,datatype e);
int update_data(linklist L,datatype e,datatype key);
int search_data(linklist L,datatype e);
int delete_data(linklist L,datatype e);
int insert_data(linklist L,datatype e,datatype key);
int insert_pos(linklist L,int pos,datatype e);
void bubble(linklist L);
linklist free_space(linklist L);
int delete_rear(linklist L);




#endif      //选择注释函数尾
//此段代码为分文件编译的XXX.h文件 存储函数头、函数声明结构体声明

#include"StructH3.h"

//建立链表头节点并做初始化
linklist create_head(int flag)
{
	linklist L=(linklist)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		return NULL;
	}
	if(flag==1)
	{
		L->len=0;//初始化头数据域
	}
	else if(flag==0)
	{
		L->data=0;
	}
	L->next=NULL;//初始化指针域
	return L;  
}

//建立链表其它节点并做初始化
linklist create_node()
{
	linklist p=(linklist)malloc(sizeof(struct Node));
	if(p==NULL)
	{
		return NULL;
	}
	p->data=0;//初始化普通节点数据域
	p->next=NULL;//初始化普通节点指针域
	return p;
}

//建立插入封装函数
int insert_head(linklist L,datatype e)
{
	if(L==NULL)//如果链表不存在返回空
	{
		return -1;
	}

	linklist s=create_head(0);
	if(s==NULL) //如果普通节点s不存在返回空
	{
		return -1;
	}
	s->data=e;  //插入过程
	s->next=L->next;
	L->next=s;
	L->len++;//L节点后移
	return 0;
}

//输出封装函数
void output(linklist L)
{
	if(L==NULL)
	{
		return;
	}

	linklist p=L; //利用p接收头节点进行遍历因头节点不能改变
	for(int i=0;i<L->len;i++)
	{
		p=p->next;//p节点后移遍历
		printf("%d ",p->data);//打印遍历的节点		
	}
	puts("");
}

//插入元素的封装函数
int update_pos(linklist L,int pos,datatype e)
{
	if(L==NULL||pos<1||pos>L->len)
	{
		return -1;
	}
	linklist p=L;
	for(int i=0;i<pos;i++) //循环遍历
	{
		p=p->next;
	}
	p->data=e;//为节点数据域赋值
	return 0;
}

//数据查找的封装函数
int search_data(linklist L,datatype e)
{
	if(L==NULL||L->next==NULL)
	{
		return -1;
	}
	linklist p=L;
	int pos=1;
	while(p->next!=NULL)//进行循环便利查找
	{
		p=p->next;
		if(p->data==e)//如果比对结果相同则返回
		{
			return pos;  
		}
		pos++;//否则后移继续遍历
	}
	return -1;
}

//删除链表节点的封装函数
int delete_pos(linklist L,int pos)
{
	if(L==NULL||pos<1||pos>L->len)//判断链表是否存在 是否为空
	{
		return -1;
	}
	linklist p=L;//定义p接收头节点带替头节点遍历
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	linklist q=p->next; //定义q 接收p的下一节点
	p->next=q->next; //p节点连接q的下一节点空出  q节点
	free(q);  //释放q节点
	q=NULL;    //指针指向空
	L->len--;    //长度减减
	return 0;
}

//查找对应位置进行删除封装函数
int update_data(linklist L,datatype e,datatype key)
{
	int pos=search_data(L,e);
	if(pos==-1)
	{
		return -1;
	}
	delete_pos(L,pos);
	return 0;;
}

//删除数据节点封装函数
int delete_data(linklist L,datatype e)
{
	int pos=search_data(L,e);
	if(pos==-1)
	{
		return -1;
	}
	delete_pos(L,pos);
	return 0;
}
//查找对应元素位置前进行插入封装函数
int insert_pos(linklist L,int pos,datatype e)
{
	if(L==NULL||pos<1||pos>L->len+1)
	{
		return -1;
	}
	linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	linklist s=create_head(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0;
}
//查找插入封装函数
int insert_data(linklist L,datatype e,datatype key)
{
	int pos=search_data(L,e);
	if(pos==-1)
	{
		return -1;
	}
	insert_pos(L,pos,key);
	return 0;
}

//链表内元素进行排序
void bubble(linklist L)
{
	if(L==NULL)
	{
		return;
	}
	if(L->len==1)
	{
		printf("只有一个元素，无需排序:");
		return ;
	}
	int count=0;
	for(linklist i=L->next;i->next!=NULL;i=i->next)
	{
		for(linklist j=L->next;j->next!=NULL;j=j->next)
		{
			if(j->data>j->next->data)
			{
				datatype t=j->data;
				j->data=j->next->data;
				j->next->data=t;
				count++;
			}
		}
		if(count==0)
		{
			break;
		}
	}
}

//链表尾部删除封装函数
int delete_rear(linklist L)
{
	if(L==NULL)
		{
		return -1;
		}
	linklist p=L;
	while(p->next->next!=NULL)
	{
		p=p->next;
	}
	linklist q=p->next;
	p->next=q->next;
	free(q);
	q=NULL;
	L->len--;
}
//释放链表封装函数
linklist free_space(linklist L)
{
	if(L==NULL)
	{
		return NULL;
	}
	int n=L->len;
	for(int i=0;i<n;i++)
	{
		delete_rear(L);
	}
	free(L);
	L=NULL;
	return L;
}
//分文件编译的被调函数XXX.c文件

#include"StructH3.h"

int main(int argc, const char *argv[])
{
	linklist L=create_head(1);
	int n,pos;datatype e;datatype key;
	printf("请输入数据元素的个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("请输入数值:");
		scanf("%d",&e);
		insert_head(L,e);
	}
	output(L);
#if 0	
	//单向表按位置修改数值
	printf("请输入修改位置:");
	scanf("%d",&pos);
	printf("请输入修改的值:");
	scanf("%d",&e);
	update_pos(L,pos,e);
	output(L);
#else
	//单向表按元素修改数值
	printf("请输被修改的值:");
	scanf("%d",&e);
	printf("请输入修改的值:");
	scanf("%d",&key);
	update_pos(L,e,key);
	output(L);
#endif

	//单向链表按元素删除数值
	printf("请输入被删除的值");
	scanf("%d",&e);
	delete_data(L,e);
	output(L);

	//单向链表在给定元素前插入数值
	printf("请输入被插入的值:");
	scanf("%d",&e);
	printf("请输入插入的值:");
	scanf("%d",&key);
	insert_data(L,e,key);
	output(L);

	//单向链表的排序
	bubble(L);
	printf("排序的结果为:");
	output(L);

	//单向链表空间释放
	L=free_space(L);
	return 0;
}

//分文件编译的主调函数XXX.c 文件。