寒假 day2

1、请编程实现单向循环链表的头插，头删、尾插、尾删

#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 insert_head(Linklist head,datatype element);
Linklist create();
void output(Linklist head);
Linklist insert_rear(Linklist head,datatype element);
Linklist det_head(Linklist head);
Linklist det_rear(Linklist head);
int main(int argc, const char *argv[])
{
	Linklist head=NULL;
	int n;
	datatype element;
	printf("please enter n;");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		head=insert_head(head,element);//头插
		//head=insert_rear(head,element);//尾插
	}
	//遍历
	output(head);
	//头删
	head=det_head(head);
	output(head);
	//尾删
	head=det_rear(head);
	output(head);
    return 0;
}
//创建新节点
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(NULL==s)
		return NULL;
	s->data=0;
	s->next=s;
	return s;
}

//头插入
Linklist insert_head(Linklist head,datatype element)
{
	//创建新节点
	Linklist s=create();
	s->data=element;

	//判断链表是否为空
	if(NULL==head)
	{
		head=s;
	}
	else
	{
		Linklist p=head;
		//找到最后一个节点
		while(p->next!=head)
		{
			p=p->next;
		}
		s->next=head;
		head=s;
		//尾节点的指针域指向head
		p->next=head;
	}
	//思路2：
	//s是第一个节点，定义一个二级指针代表s节点
	//头插时s不断后移，因此二级指针永远是最后一个节点
	//所以，可以不用循环寻找最后一个节点
	//二级指针直接指向head即可
	//此思路因不用循环查找，时间复杂度降低
	return head;
}

//遍历输出
void output(Linklist head)
{
	//判断链表是否为空
	if(NULL==head)
	{
		puts("empty");
		return;
	}
	//输出
	Linklist p=head;
	do //先执行 后判断
	{
		printf("%d ",p->data);
		p=p->next;//后移
	}while(p!=head);
	puts("");
}

//尾插
Linklist insert_rear(Linklist head,datatype element)
{
	//创建新节点
	Linklist s=create();
	s->data=element;

	//判断链表是否为空
	if(NULL==head)
	{
		head=s;
	}
	else //存在多个链表
	{
		Linklist p=head;
		//找到最后一个节点
		while(p->next!=head)
		{
			p=p->next;
		}
		p->next=s;
		//尾节点的指针域指向head
		s->next=head;
	}
	return head;
}

//头删
Linklist det_head(Linklist head)
{
	//判断链表是否为空
	if(NULL==head)
		return head;
	//存在多个节点 >=1
	Linklist del=head;
	Linklist p=head;
	while(p->next!=head)
		p=p->next;
	head=head->next;
	free(del);
	del=NULL;
	//尾节点的指针域指向head
	p->next=head;
	return head;
}
//尾删
Linklist det_rear(Linklist head)
{
	//判断链表是否为空
	if(NULL==head)
		return head;
	//一个节点
	else if(head->next==head)
	{
		free(head);
		head=NULL;
		return head;
	}
	//多个节点 >=2
	else
	{
		Linklist del=head;
		//找到倒数第二个节点
		while(del->next->next!=head)
		{
			del=del->next;
		}
		free(del->next);
		//倒数第二个节点指针域指向head
		del->next=head;
		return head;
	}
}

2、请编程实现单向循环链表约瑟夫环
约瑟夫环:用循环链表编程实现约瑟夫问题
n个人围成一圈，从某人开始报数1,2,..., m，数到m的人出圈，然后从出圈的下一个人(m+1)开始重复此过程
直到 全部人出圈，于是得到一个出圈人员的新序列
如当n=8，m=4时，若从第一个位置数起，则所得到的新的序列 为4,8,5,2,1,3,7,6

#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();
void output(Linklist head);
Linklist insert_rear(Linklist head,datatype element);
Linklist yusef(Linklist head,int n,int m);
int main(int argc, const char *argv[])
{
	Linklist head=NULL;
	int n;
	datatype element;
	printf("please enter n;");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
		head=insert_rear(head,element);//尾插
	}
	//约瑟夫循环输出
	int m;
	printf("please enter m:");
	scanf("%d",&m);
	head=yusef(head,n,m);
	output(head);
	return 0;
}
Linklist yusef(Linklist head,int n,int m)
{
	if(NULL==head)
		return head;
	Linklist p=head;
	for(int i=0;i<n;i++)//轮数
	{
		for(int j=0;j<m-2;j++)//次数
		{
			p=p->next;
		}
		Linklist del=p->next;
		p->next=del->next;
		printf("%-5d",del->data);
		free(del);
		del=NULL;
		p=p->next;
	}
	return NULL;
}
//创建新节点
Linklist create()
{
	Linklist s=(Linklist)malloc(sizeof(struct Node));
	if(NULL==s)
		return NULL;
	s->data=0;
	s->next=s;
	return s;
}
//遍历输出
void output(Linklist head)
{
	//判断链表是否为空
	if(NULL==head)
	{
		puts("empty");
		return;
	}
	//输出
	Linklist p=head;
	do //先执行 后判断
	{
		printf("%d ",p->data);
		p=p->next;//后移
	}while(p!=head);
	puts("");
}
//尾插
Linklist insert_rear(Linklist head,datatype element)
{
	//创建新节点
	Linklist s=create();
	s->data=element;

	//判断链表是否为空
	if(NULL==head)
	{
		head=s;
	}
	else //存在多个链表
	{
		Linklist p=head;
		//找到最后一个节点
		while(p->next!=head)
		{
			p=p->next;
		}
		p->next=s;
		//尾节点的指针域指向head
		s->next=head;
	}
	return head;
}

3、请编程实现单向循环链表的排序

#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 s=(Linklist)malloc(sizeof(struct Node));
	if(NULL==s)
		return NULL;
	//成功则初始化
	s->data=0;
	s->next=s;
	return s;
}
int length(Linklist head)
{
	int len=0;
	Linklist p=head;
	while(p->next!=head)
	{
		len++;
		p=p->next;
	}
    len++;
	return len;
}
Linklist insert_rear(Linklist head,datatype element)
{
	
	//创建新节点s
	Linklist s=create();
	s->data=element;

	//1,判断链表是否为空
	if(NULL==head)
		head=s;
	else//2,存在多个节点
	{
		//循环到最后一个节点
		Linklist p=head;
		while(p->next!=head)
		{
			p=p->next;
		}
		p->next=s;
		//尾节点的指针域指向头
		s->next=head;
	}
	return head;
}
void output(Linklist head)
{
	//1,判断链表是否为空
	if(NULL==head)
	{
		puts("empty");
		return;
	}
	//2,循环遍历
	Linklist p=head;
	do
	{
		printf("%-5d",p->data);
		p=p->next;//后移
	}while(p!=head);
	puts("");
}
void Bubble(Linklist head)
{
	if(NULL==head)
		return;
	int len=length(head);
	for(int i=1;i<len;i++)
	{
		Linklist p=head;
		for(int j=0;j<len-i;j++)
		{
			if(p->data > p->next->data)
			{
				datatype t=p->data;
				p->data=p->next->data;
				p->next->data=t;
			}
				p=p->next;
		}
	}
}
int main(int argc, const char *argv[])
{
	Linklist head=NULL; //定义单链表的头指针
	int n;
	datatype element;//插入的值
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter %d element:",i+1);
		scanf("%d",&element);
	//	head=insert_head(head,element);
		head=insert_rear(head,element);
	}
	Bubble(head);
	output(head);
	return 0;
}