寒假作业：2024/2/3

最新推荐文章于 2024-08-08 18:22:07 发布

FS223107

最新推荐文章于 2024-08-08 18:22:07 发布

阅读量396

点赞数 9

文章标签：网络算法

本文链接：https://blog.csdn.net/FS223107/article/details/136006387

版权

作业1：编程实现单向循环链表的头插、头删、尾插、尾删

1.头插：

代码：

#include "head.h"
/*
 * function:    单向循环链表新节点创建
 * @param [ in] 
 * @param [out] 
 * @return      成功返回创建的节点，失败NULL
 */
loop_linklist create()
{
	//堆区申请内存创建新节点
	loop_linklist s=(loop_linklist)malloc(sizeof(struct Node));
	//失败返回NULL
	if(NULL==s)
		return NULL;
	//成功则初始化并返回节点
	s->data=0;
	s->next=s;
	return s;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 头，插入的值
 * @return      头
 */
loop_linklist inster_head(loop_linklist head,datatype element)
{
	//创建新节点
	loop_linklist s=create();
	s->data=element;
	//链表为空
	if(NULL==head){
		head=s;
	}else{//链表不为空
		loop_linklist p=head;
		while(p->next!=head)
		{
			p=p->next;
		}
		s->next=head;
		head=s;
		p->next=head;
	}
	return head;
}

效果图：

2.头删：

代码：

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 头
 * @return      头
 */
loop_linklist delete_head(loop_linklist head)
{
	//链表为空
	if(NULL==head)
		return head;
	//链表不为空
	//先找到最后一个节点
	loop_linklist p=head->next;
	while(p->next!=head)
	{
		p=p->next;
	}
	//开始头插
	loop_linklist del=head;
	head=head->next;
	free(del);
	del=NULL;
	p->next=head;
	return head;
}

效果图：

3.尾插：

代码：

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 头，插入的值
 * @return      头
 */
loop_linklist inster_rear(loop_linklist head,datatype element)
{
	//创建新节点
	loop_linklist s=create();
	s->data=element;
	//如果链表为空
	if(NULL==head){
		head=s;
	}else{//链表不为空
		//先循环到最后一个节点
		loop_linklist p=head;
		while(p->next!=head)
		{
			p=p->next;
		}
		//再尾插
		p->next=s;
		s->next=head;
	}
	return head;
}

效果图：

4.尾删：

代码：

/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 头
 * @return      头
 */
loop_linklist delete_rear(loop_linklist head)
{
	//如果链表为空
	if(NULL==head)
		return head;
	//链表不为空
	//只有一个节点
	if(head->next==head){
		free(head);
		head=NULL;
	}else{//有多个节点
		loop_linklist del=head;
		while(del->next->next!=head)
		{
			del=del->next;
		}
		free(del->next);
		del->next=head;
	}
	return head;
}

效果图：

作业2：编程实现单向循环链表约瑟夫环

代码：

/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 头，m
 * @return      NULL
 */
loop_linklist joseph(loop_linklist head,int n,int m)
{
	//如果链表为空
	if(NULL==head)
		return head;
	//链表不为空
	loop_linklist p=head;
	for(int i=0;i<n;i++)//外层控制出圈的轮数
	{
		for(int j=0;j<m-2;j++)//内层控制每轮要出圈的人
		{
			p=p->next;
		}
		//删除p的后继
		loop_linklist del=p->next;
		printf("%-4d",del->data);
		p->next=del->next;
		free(del);
		del=NULL;
		p=p->next;
	}
	puts("");
	return NULL;
}

效果图：

作业3：编程实现单向循环链表的排序

代码：

/*
 * function:    简单选择排序
 * @param [ in] 
 * @param [out] 头
 * @return      无
 */
void Simple(loop_linklist head)
{
	//如果链表为空
	if(NULL==head)
		return;
	//链表不为空
	for(loop_linklist i=head;i->next!=head;i=i->next)
	{
		loop_linklist min=i;
		for(loop_linklist j=i->next;j!=head;j=j->next)
		{
			if(min->data>j->data)
			{
				min=j;
			}
		}
		if(min!=i)
		{
			datatype t=min->data;
			min->data=i->data;
			i->data=t;
		}
	}
}

效果图：

总代码：

head.h:

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//数据域元素类型重定义
typedef int datatype;
//单向循环链表结构体的类型重定义
typedef struct Node
{
	//数据域
	datatype data;
	//指针域
	struct Node *next;
}*loop_linklist;

loop_linklist create();
loop_linklist inster_head(loop_linklist head,datatype element);
loop_linklist delete_head(loop_linklist head);
loop_linklist inster_rear(loop_linklist head,datatype element);
loop_linklist delete_rear(loop_linklist head);
loop_linklist joseph(loop_linklist head,int n,int m);
void Simple(loop_linklist head);
void output(loop_linklist head);

#endif

main.c:

#include "head.h"

int main(int argc, const char *argv[])
{
	loop_linklist head=NULL;
	int n;
	printf("please enter n:");
	scanf("%d",&n);
	datatype element;
	for(int i=0;i<n;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		//循环调用头插
		head=inster_head(head,element);
		//循环调用尾插
		head=inster_rear(head,element);
	}
	//单向循环链表的遍历
	output(head);

	//单向循环链表的头删
	head=delete_head(head);
	output(head);

	//单向循环链表的尾删
	head=delete_rear(head);
	output(head);

	//约瑟夫环问题
	int m;
	printf("please enter m:");
	scanf("%d",&m);
	head=joseph(head,n,m);
	output(head);

	//简单选择排序
	Simple(head);
	output(head);

	return 0;
}

test.c:

#include "head.h"
/*
 * function:    单向循环链表新节点创建
 * @param [ in] 
 * @param [out] 
 * @return      成功返回创建的节点，失败NULL
 */
loop_linklist create()
{
	//堆区申请内存创建新节点
	loop_linklist s=(loop_linklist)malloc(sizeof(struct Node));
	//失败返回NULL
	if(NULL==s)
		return NULL;
	//成功则初始化并返回节点
	s->data=0;
	s->next=s;
	return s;
}
/*
 * function:    头插
 * @param [ in] 
 * @param [out] 头，插入的值
 * @return      头
 */
loop_linklist inster_head(loop_linklist head,datatype element)
{
	//创建新节点
	loop_linklist s=create();
	s->data=element;
	//链表为空
	if(NULL==head){
		head=s;
	}else{//链表不为空
		loop_linklist p=head;
		while(p->next!=head)
		{
			p=p->next;
		}
		s->next=head;
		head=s;
		p->next=head;
	}
	return head;
}
/*
 * function:    头删
 * @param [ in] 
 * @param [out] 头
 * @return      头
 */
loop_linklist delete_head(loop_linklist head)
{
	//链表为空
	if(NULL==head)
		return head;
	//链表不为空
	//先找到最后一个节点
	loop_linklist p=head->next;
	while(p->next!=head)
	{
		p=p->next;
	}
	//开始头插
	loop_linklist del=head;
	head=head->next;
	free(del);
	del=NULL;
	p->next=head;
	return head;
}
/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 头，插入的值
 * @return      头
 */
loop_linklist inster_rear(loop_linklist head,datatype element)
{
	//创建新节点
	loop_linklist s=create();
	s->data=element;
	//如果链表为空
	if(NULL==head){
		head=s;
	}else{//链表不为空
		//先循环到最后一个节点
		loop_linklist p=head;
		while(p->next!=head)
		{
			p=p->next;
		}
		//再尾插
		p->next=s;
		s->next=head;
	}
	return head;
}
/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 头
 * @return      头
 */
loop_linklist delete_rear(loop_linklist head)
{
	//如果链表为空
	if(NULL==head)
		return head;
	//链表不为空
	//只有一个节点
	if(head->next==head){
		free(head);
		head=NULL;
	}else{//有多个节点
		loop_linklist del=head;
		while(del->next->next!=head)
		{
			del=del->next;
		}
		free(del->next);
		del->next=head;
	}
	return head;
}
/*
 * function:    约瑟夫环
 * @param [ in] 
 * @param [out] 头，m
 * @return      NULL
 */
loop_linklist joseph(loop_linklist head,int n,int m)
{
	//如果链表为空
	if(NULL==head)
		return head;
	//链表不为空
	loop_linklist p=head;
	for(int i=0;i<n;i++)//外层控制出圈的轮数
	{
		for(int j=0;j<m-2;j++)//内层控制每轮要出圈的人
		{
			p=p->next;
		}
		//删除p的后继
		loop_linklist del=p->next;
		printf("%-4d",del->data);
		p->next=del->next;
		free(del);
		del=NULL;
		p=p->next;
	}
	puts("");
	return NULL;
}
/*
 * function:    简单选择排序
 * @param [ in] 
 * @param [out] 头
 * @return      无
 */
void Simple(loop_linklist head)
{
	//如果链表为空
	if(NULL==head)
		return;
	//链表不为空
	for(loop_linklist i=head;i->next!=head;i=i->next)
	{
		loop_linklist min=i;
		for(loop_linklist j=i->next;j!=head;j=j->next)
		{
			if(min->data>j->data)
			{
				min=j;
			}
		}
		if(min!=i)
		{
			datatype t=min->data;
			min->data=i->data;
			i->data=t;
		}
	}
}
/*
 * function:    循环链表的遍历
 * @param [ in] 
 * @param [out] 头
 * @return      无
 */
void output(loop_linklist head)
{
	//链表为空
	if(NULL==head)
		return;
	//链表不为空
	loop_linklist p=head;
	do
	{
		printf("%-4d",p->data);
		p=p->next;
	}while(p!=head);
	puts("");
}