2024.4.3作业

1、单向循环链表（头插、尾插、头删、尾删、按位置插入、删除、查询、遍历）

#ifndef __LOOPLINK__H                                                        
#define __LOOPLINK__H                                                        
                                                                             
typedef int datatype;                                                        
typedef struct  node{                                                        
    datatype data;                                                           
    struct node * next;                                                      
}loopLink_list;                                                              
loopLink_list *  creat_loop_Linklist(void);                                  
void headInsert_loopLinkList(loopLink_list* head,datatype  num);             
void show_loopLinklist(loopLink_list* head);                                 
void  tailInesrt_loopLinklist(loopLink_list* head,datatype num);             
datatype  headDel_loopLinklist(loopLink_list* head);                         
datatype  tailDel_loopLinklist(loopLink_list* head);                         
void pos_insert_loopLinkliet(loopLink_list* head,int pos,datatype num);      
void posDel_loopLinklist(loopLink_list*head,int pos);                        
void queryByPos_loopLinklist(loopLink_list*head,int pos);                    
                                                                             
                                                                             
#endif                                                                       
                                                                             

#include <stdio.h>                                                 
#include <stdlib.h>                                                
#include "./3_loopLink.h"                                          
                                                                   
int main(int argc, const char *argv[])                             
{                                                                  
loopLink_list *head=creat_loop_Linklist();                         
printf("%p\n",head);                                               
headInsert_loopLinkList(head,100);                                 
headInsert_loopLinkList(head,200);                                 
headInsert_loopLinkList(head,300);                                 
show_loopLinklist(head);                                           
tailInesrt_loopLinklist(head,400);                                 
tailInesrt_loopLinklist(head,500);                                 
tailInesrt_loopLinklist(head,600);                                 
show_loopLinklist(head);                                           
headDel_loopLinklist(head);                                        
show_loopLinklist(head);                                           
tailDel_loopLinklist(head);                                        
show_loopLinklist(head);                                           
pos_insert_loopLinkliet(head,0,11);                                
show_loopLinklist(head);                                           
pos_insert_loopLinkliet(head,4,999);                               
show_loopLinklist(head);                                           
pos_insert_loopLinkliet(head,6,9999);                              
show_loopLinklist(head);                                           
pos_insert_loopLinkliet(head,8,9999);                              
posDel_loopLinklist(head,6);                                       
show_loopLinklist(head);                                           
posDel_loopLinklist(head,1);                                       
show_loopLinklist(head);                                           
posDel_loopLinklist(head,5);                                       
queryByPos_loopLinklist(head, 5);                                  
queryByPos_loopLinklist(head, 4);                                  
                                                                   
                                                                   
    return 0;                                                      
}                                                                  
                                                                   
                                                                   
                                                                   

/*
 * function:    //创建单向循环链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */

#include <stdio.h>
#include <stdlib.h>
#include "./3_loopLink.h" 

loopLink_list *  creat_loop_Linklist(void)
{
	loopLink_list * head=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==head)
	{
		printf("malloc  error!\n");
		return NULL;
	}
	head->next=head;
	return head;
}

/*
 * function:    //头插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void headInsert_loopLinkList(loopLink_list* head,datatype  num)
{
	loopLink_list * temp=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==temp)
	{
		printf("malloc  error!\n");
		return ;
	}
	temp->data=num;
	temp->next=head->next;
	head->next=temp;
	return ;
}


/*
 * function:    //尾插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void  tailInesrt_loopLinklist(loopLink_list* head,datatype num)
{
	//创建结点
	loopLink_list * temp=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==temp)
	{
		printf("malloc  error!\n");
		return ;
	}
	//找尾巴
	loopLink_list *p=head;
	while(p->next!=head)
		p=p->next;
	//插入结点
	temp->data=num;
	temp->next=p->next;
	p->next=temp;
	return;
}

/*
 * function:    //头删法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype  headDel_loopLinklist(loopLink_list* head)
{
	loopLink_list* p=head->next;
	datatype num=0;
	if(p==head)
	{
		printf("链表为空，删除失败！\n");
		return (datatype)-1;
	}
	else
	{
		head->next=p->next;
		num=p->data;
		free(p);
		p=NULL;
		return num;
	}
}

/*
 * function:    //尾删法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype  tailDel_loopLinklist(loopLink_list* head)
{
	loopLink_list* p=head;
	datatype num=0;
	if(p->next==head)
	{
		printf("链表为空，删除失败！\n");
		return (datatype)-1;
	}
	while(p->next->next!=head)
		p=p->next;
	loopLink_list* temp =p->next;
	p->next=head;
	num=temp->data;
	free(temp);
	temp=NULL;
	return num;
}



/*
 * function:    //遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void show_loopLinklist(loopLink_list* head)
{
	loopLink_list* p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("%d\t",p->data);
	}
	putchar(10);
	if(p==head)
		printf("链表为空，遍历失败！\n");
	return ; 
}
/*
 * function:    //循环链表长度
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int len_loopLinklist(loopLink_list* head)
{
	int len=0;
	loopLink_list *p=head;
	while(p->next!=head)
	{
		p=p->next;
		len++;
	}
	return len;
}


/*
 * function:    //  按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void pos_insert_loopLinkliet(loopLink_list* head,int pos,datatype num)
{
	int len=len_loopLinklist(head);
	loopLink_list *p=head;
	if(pos<=0 ||pos>len+1)
	{
		printf("插入位置超出链表，插入失败！\n");
		return;
	}
	for(int i=0;i<pos-1;i++)
		p=p->next;
	loopLink_list * temp=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==temp)
	{
		printf("malloc  error!\n");
		return ;
	}
	temp->data=num;
	temp->next=p->next;
	p->next=temp;
	return ;
}
/*
 * function:    //按位置删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void posDel_loopLinklist(loopLink_list*head,int pos)
{
	loopLink_list *p=head;
	//判断是否为空
	if(p->next==head)
	{
		printf("循环链表为空，按位置删除失败！\n");
		return;
	}
	//判断pos是否合法
	int len=len_loopLinklist(head);
	if(pos<=0 || pos>len)
	{
		printf("删除位置超出循环链表，按位置删除失败！\n");
		return;
	}
	//找到pos的上个结点
	for(int i=0;i<pos-1;i++)
		p=p->next;
	//删除并释放空间
	loopLink_list * temp=p->next;
	p->next=p->next->next;
	free(temp);
	temp=NULL;
	return;
}


/*
 * function:    //按位置查询
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void queryByPos_loopLinklist(loopLink_list*head,int pos)
{
	loopLink_list *p=head;
	//判断是否为空
	if(p->next==head)
	{
		printf("循环链表为空，按位置查询失败！\n");
		return;
	}
	//判断pos是否合法
	int len=len_loopLinklist(head);
	if(pos<=0 || pos>len)
	{
		printf("查询位置超出循环链表，按位置查询失败！\n");
		return;
	}
	//找到pos结点
	for(int i=0;i<pos;i++)
		p=p->next;
	//显示数据
	printf("循环链表结点%d的数据是：%d\n",pos,p->data);
	return;
}

2、joseph(约瑟夫)问题

设编号分别为：1，2，…，n的n个人围坐一圈。

约定序号为k（1≤k≤n）的人从1开始计数，数到m的那个人出列，

他的下一位又从1开始计数，数到m的那个人又出列，依次类推，直到所有人出列为止。

例如，8个人围坐一圈，约定从第3个人开始编号为1，数到第4个人出列。出列后原来第5个人计算为1.     n=8，k=3，m=4，最终出队的结果是6 2 7 4 3 5 1 8

#ifndef __LOOPLINK__H                                                   
#define __LOOPLINK__H                                                   
                                                                        
typedef int datatype;                                                   
typedef struct  node{                                                   
    datatype data;                                                      
    struct node * next;                                                 
}loopLink_list;                                                         
loopLink_list *  creat_loop_Linklist(void);                             
void  tailInesrt_loopLinklist(loopLink_list* head,datatype num);        
loopLink_list*  del_headNode(loopLink_list* head);                      
void show_loopLinklist(loopLink_list* head);                            
void show_loopLinklist_ByTempHead(loopLink_list* temp_head);            
loopLink_list * k_node(loopLink_list* temp_head,int k );                
loopLink_list*  DelBy_pos_Linklist(loopLink_list* temp_head ,int m);    
                                                                        
                                                                        
#endif                                                                  
                                                                        

#include <stdio.h>                                                         
#include <stdlib.h>                                                        
#include "./3_loopLink.h"                                                  
                                                                           
int main(int argc, const char *argv[])                                     
{                                                                          
    int n,k,m;                                                             
    do                                                                     
    {                                                                      
        printf("第一步：请输入合理的围坐人数n(编号依次为1—n：>>>");        
        scanf("%d",&n);                                                    
        getchar();                                                         
    }                                                                      
    while(n<1);                                                            
    do                                                                     
    {                                                                      
        printf("第二步：请输入合理的起始人员编号k：>>>");                  
        scanf("%d",&k);                                                    
        getchar();                                                         
    }                                                                      
    while(k<1||k>n);                                                       
    do                                                                     
    {                                                                      
        printf("第三步：请输入合理的人员出圈数m:>>>");                     
        scanf("%d",&m);                                                    
        getchar();                                                         
    }                                                                      
    while(m<1);                                                            
    //创建单向循环链表头结点                                               
    loopLink_list *head=creat_loop_Linklist();                             
    //尾插人员并依次分配座号                                               
    for(int i=1;i<=n;i++)                                                  
        tailInesrt_loopLinklist(head,i);                                   
    //show_loopLinklist(head);                                             
    //删除头结点,顺位作为临时头结点                                        
    loopLink_list *tempHead=del_headNode(head);                            
    //show_loopLinklist_ByTempHead(tempHead);                              
    //找到启动座号，当做临时头结点                                         
    tempHead=k_node(tempHead,k);                                           
    //show_loopLinklist_ByTempHead(tempHead);                              
    //每次按照m位置出圈，并打印出圈座号                                    
    if(1==m)                                                               
        show_loopLinklist_ByTempHead(tempHead);                            
    else                                                                   
    {                                                                      
        while(tempHead!=NULL)                                              
            tempHead=DelBy_pos_Linklist(tempHead,m);                       
        putchar(10);                                                       
    }                                                                      
    return 0;                                                              
}                                                                          
                                                                           

/*
 * function:    //创建单向循环链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */

#include <stdio.h>
#include <stdlib.h>
#include "./3_loopLink.h" 

loopLink_list *  creat_loop_Linklist(void)
{
	loopLink_list * head=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==head)
	{
		printf("malloc  error!\n");
		return NULL;
	}
	head->next=head;
	return head;
}
/*                                                                     
 * function:    //尾插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void  tailInesrt_loopLinklist(loopLink_list* head,datatype num)
{
	//创建结点
	loopLink_list * temp=(loopLink_list*)malloc(sizeof(loopLink_list));
	if(NULL==temp)
	{
		printf("malloc  error!\n");
		return ;
	}
	//找尾巴
	loopLink_list *p=head;
	while(p->next!=head)
		p=p->next;
	//插入结点
	temp->data=num;
	temp->next=p->next;
	p->next=temp;
	return;
}


/*
 * function:    //删除头结点,顺位为临时头结点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
loopLink_list*  del_headNode(loopLink_list* head)
{
	loopLink_list* p=head;
	while(p->next!=head)
		p=p->next;
	loopLink_list* tempHead=head->next;
	p->next=head->next;
	free(head);
	head=NULL;
	return tempHead;
}


/*
 * function:    //找到结点K
 * @param [ in] 
 * @param [out] 
 * @return      
 */
loopLink_list * k_node(loopLink_list* temp_head,int k )
{
	for(int i=0;i<k-1;i++)
		temp_head=temp_head->next;
	return temp_head;
}

/*
 * function:    //按照pos删除结点，并输出被删除结点数据
 * @param [ in] 
 * @param [out] 
 * @return      
 */
loopLink_list*  DelBy_pos_Linklist(loopLink_list* temp_head ,int m)
{
	loopLink_list *p=temp_head;
	if(p!=p->next)	//两个及以上结点
	{
		for(int i=1;i<m-1;i++)
			p=p->next;
		loopLink_list* temp=p->next;
		temp_head=temp->next;
		p->next=temp_head;
		printf("%d\t",temp->data);
		free(temp);
		temp=NULL;
		return temp_head;
	}
	else	//只有一个结点
	{
		printf("%d\t",p->data);
		free(p);
		p=NULL;
		return NULL;
	}
}


/*
 * function:    //无头结点链表遍历
 * @param [ in] 
 * @param [out] 
 * @return                                    
 */
void show_loopLinklist_ByTempHead(loopLink_list* temp_head)
{
	loopLink_list* p=temp_head;
	while(p->next!=temp_head)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	printf("%d\n",p->data);
	return;
}
/*
 * function:    //有头结点遍历
 * @param [ in] 
 * @param [out] 
 * @return                                    
 */
void show_loopLinklist(loopLink_list* head)
{
	loopLink_list* p=head;
	while(p->next!=head)
	{
		p=p->next;
		printf("%d\t",p->data);
	}
	putchar(10);
	if(p==head)
		printf("链表为空，遍历失败！\n");
	return ;
}

3、双向链表（头插、尾插、头删、尾删、按位置插入、删除、查询、遍历）

#ifndef __DOUBLELINK__H                                                           
#define __DOUBLELINK__H                                                           
                                                                                  
typedef int datatype;                                                             
typedef struct  needle                                                            
{                                                                                 
    datatype data;                                                                
    struct needle *prev;                                                          
    struct needle * next;                                                         
}doubleLink_list;                                                                 
doubleLink_list *  creat_double_Linklist(void);                                   
void headInsert_doubleLink_list(doubleLink_list* head,datatype num);              
void showDoubleLoop_Linklist(doubleLink_list *head);                              
void showDoubleLoop_Linklist_fromTail(doubleLink_list *head);                     
void tailInsert_doubleLinklist(doubleLink_list * head,datatype num);              
datatype HeadDel_doubleLinklist(doubleLink_list * head);                          
datatype TailDel_doubleLinklist(doubleLink_list * head);                          
void insert_doubleLinklist_ByPos(doubleLink_list *head,int pos,datatype num);     
datatype  delete_doubleLinklist_ByPos(doubleLink_list *head,int pos);             
datatype  query_doubleLinklist(doubleLink_list* head,int pos);                    
                                                                                  
                                                                                  
#endif                                                                            

#include <stdio.h>                                                    
#include <stdlib.h>                                                   
#include "./3_DoubleLink.h"                                           
                                                                      
int main(int argc, const char *argv[])                                
{                                                                     
                                                                      
    doubleLink_list *head=creat_double_Linklist();                    
    printf("%p\n",head);                                              
    headInsert_doubleLink_list(head,100);                             
    headInsert_doubleLink_list(head,200);                             
    showDoubleLoop_Linklist(head);                                    
    tailInsert_doubleLinklist(head,300);                              
    tailInsert_doubleLinklist(head,400);                              
    showDoubleLoop_Linklist(head);                                    
    HeadDel_doubleLinklist(head);                                     
    showDoubleLoop_Linklist(head);                                    
    TailDel_doubleLinklist(head);                                     
    showDoubleLoop_Linklist(head);                                    
    insert_doubleLinklist_ByPos(head,1,400);                          
    showDoubleLoop_Linklist(head);                                    
    delete_doubleLinklist_ByPos(head,4);                              
    delete_doubleLinklist_ByPos(head,3);                              
    showDoubleLoop_Linklist(head);                                    
    query_doubleLinklist(head,1);                                     
    query_doubleLinklist(head,2);                                     
    query_doubleLinklist(head,3);                                     
                                                                      
                                                                      
    return 0;                                                         
}                                                                     
                                                                      

/*
 * function:    //创建双向链表
 * @param [ in] 
 * @param [out] 
 * @return      
 */

#include <stdio.h>
#include <stdlib.h>
#include "./3_DoubleLink.h" 

doubleLink_list *  creat_double_Linklist(void)
{
	doubleLink_list * head=(doubleLink_list*)malloc(sizeof(doubleLink_list));
	if(NULL==head)
	{
		printf("malloc  error!\n");
		return NULL;
	}
	head->prev=NULL;
	head->next=NULL;
	return head;
}

/*
 * function:    //头插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void headInsert_doubleLink_list(doubleLink_list* head,datatype num)
{
	//创建双向链表结点
	doubleLink_list *temp=(doubleLink_list*)malloc(sizeof(doubleLink_list));
	if(NULL==temp)
	{
		printf("malloc error!\n");
		return;
	}
	//头部插入（分为空链表头插和非空头插）
	doubleLink_list *p=head->next;
	temp->data=num;
	temp->next=head->next;
	head->next=temp;
	temp->prev=head;
	if(p!=NULL)
		temp->next->prev=temp;
	return;
}



/*
 * function:    //尾插法
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void tailInsert_doubleLinklist(doubleLink_list * head,datatype num)
{
	//创建双向链表结点
	doubleLink_list *temp=(doubleLink_list*)malloc(sizeof(doubleLink_list));
	if(NULL==temp)
	{
		printf("malloc error!\n");
		return;
	}
	//找到尾部
	doubleLink_list *p=head;
	while(p->next!=NULL)
		p=p->next;
	//尾部插入
	temp->data=num;
	temp->next=NULL;
	temp->prev=p;
	p->next=temp;
	return;
}

/*
 * function:    //头删除法
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype  HeadDel_doubleLinklist(doubleLink_list * head)
{
	doubleLink_list * p=head->next;
	//判断是否为空
	if(p==head)
	{
		printf("链表为空，无法删除！\n");
		return (datatype)-1;
	}
	//头删除法，只有一个有效结点时是特殊情况
	head->next=p->next;
	if(p->next!=NULL)
		p->next->prev=head;
	datatype res=p->data;
	free(p);
	p=NULL;

	return  res;
}


/*
 * function:    //尾巴删除法
 * @param [ in] 
 * @param [out] 
 * @return      
 */

datatype  TailDel_doubleLinklist(doubleLink_list * head)
{
	doubleLink_list * p=head->next;
	//判断是否为空
	if(p==head)
	{
		printf("链表为空，无法删除！\n");
		return (datatype)-1;
	}
	//尾删除法	
	while(p->next!=NULL)
		p=p->next;
	p->prev->next=NULL;
	datatype res=p->data;
	free(p);
	p=NULL;

	return  res;
}
/*
 * function:    //双向链表len
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int len_doubleLinklist(doubleLink_list* head)
{
	doubleLink_list * p=head;
	int len=0;
	while(p->next!=NULL)
	{
		p=p->next;
		len++;
	}
	return len;
}
/*
 * function:    //按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void insert_doubleLinklist_ByPos(doubleLink_list *head,int pos,datatype num)
{
	doubleLink_list *p=head;
	//创建双向链表结点
	doubleLink_list *temp=(doubleLink_list*)malloc(sizeof(doubleLink_list));
	if(NULL==temp)
	{
		printf("malloc error!\n");
		return;
	}
	//判断位置是否合法
	int len=len_doubleLinklist(p);
	if(pos<1 || pos>len+1)
	{
		printf("插入位置超出链表，按位置插入失败！\n");
		return ;
	}
	//找到插入位置的前个结点
	for(int i=0;i<pos-1;i++)
		p=p->next;
	//按pos插入，注意尾部插入与中间插入有区别
	temp->data=num;
	temp->next=p->next;
	temp->prev=p;
	p->next=temp;
	if(pos!=len+1)
		p->next->prev=temp;
	return;
}


/*
 * function:    //按位置删除
 * @param [ in] 
 * @param [out] 
 * @return      
 */

datatype  delete_doubleLinklist_ByPos(doubleLink_list *head,int pos)
{
	doubleLink_list *p=head;
	//判断是否为空
	if(p->next==head)
	{
		printf("链表为空，无法删除！\n");
		return (datatype)-1;
	}
	//判断位置是否合法
	int len=len_doubleLinklist(p);
	if(pos<1 || pos>len)
	{
		printf("位置超出链表，按位置删除失败！\n");
		return (datatype)-1;
	}
	//找到删除位置的结点
	for(int i=0;i<pos;i++)
		p=p->next;
	//按pos位置删除，注意尾部删除与中间删除有区别
	p->prev->next=p->next;
	if(pos!=len)
		p->next->prev=p->prev;
	datatype res=p->data;
	return res;
}


/*
 * function:    //按位置查询
 * @param [ in] 
 * @param [out] 
 * @return      
 */
datatype  query_doubleLinklist(doubleLink_list* head,int pos)
{
	doubleLink_list *p=head;
	//判断位置是否合法
	int len=len_doubleLinklist(p);
	if(pos<1 || pos>len)
	{
		printf("查询位置超出链表，按位置查询失败！\n");
		return (datatype)-1;
	}
	for(int i=0;i<pos;i++)
		p=p->next;
	printf("双向循环链表位置%d的数据是%d\n",pos,p->data);
	return p->data;
}



/*
 * function:    //从头结点正向遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void showDoubleLoop_Linklist(doubleLink_list *head)
{
	//判断是否为空
	doubleLink_list *p=head->next;
	if(p==head)
		printf("双循环链表为空，遍历失败！");
	//不为空遍历
	while(p!=NULL)
	{
		printf("%d\t",p->data);
		p=p->next;
	}
	putchar(10);
	return;
}

/*
 * function:    //从尾结点反向遍历
 * @param [ in] 
 * @param [out] 
 * @return      
 */

void showDoubleLoop_Linklist_fromTail(doubleLink_list *head)
{
	//判断是否为空
	doubleLink_list *p=head;
	if(p->next==head)
		printf("双循环链表为空，遍历失败！\n");
	//找到尾结点
	while(p->next!=NULL)
		p=p->next;
	//从尾结点遍历
	while(p!=head)
	{
		printf("%d\t",p->data);
		p=p->prev;
	}
	putchar(10);
	return;
}