约瑟夫问题 循环单链表解法

   m_prear  是指向单链表的尾部的指针。m_prear  ->m_next 是指向头指针。

 函数YSF就是对约瑟夫问题的求解方法函数。

#include<iostream>
using namespace std;
#include "stdlib.h"
#define  N 13
template <typename TypeName>
class  node
{
public:
	node()
	{
		m_next=NULL;
	}
	~node()
	{
		m_next=NULL;
	}
	TypeName m_node;
	node * m_next;
protected:
private:
	
};
template <typename TypeName>
class CircleList
{
public:
	CircleList()
	{
		m_prear=NULL;
		m_isize=0;
	}
	~CircleList()
	{
		if (m_prear==NULL)
		    return;
		node<TypeName>* p=m_prear;
		node<TypeName>* q=NULL;
		int i=0;
		while (p->m_next!=m_prear)
		{  
			q=p;
		    p=p->m_next;
			delete q;
			std::cout<< "delete" <<++i <<endl;
		}
		delete p;
		cout<< "delete" <<++i <<endl;
	}
	void addTail(node<TypeName> element);
	void inserList(int index,node<TypeName> element);
	void showList();
	void delList(int index);
	int  getSize()
	{
		return m_isize;
	}
	void YSF(int iN,int index);
	
private:
	node<TypeName>*  m_prear;
	int  m_isize;
};
//定义参数  返回值 类的实例化 ：：成员函数
template <typename TypeName>
void  CircleList<TypeName>:: YSF(int iN,int index)
{
	if (index<1)

		return;
	
	node<TypeName>*p=  m_prear->m_next;
	node<TypeName>*q=m_prear;
	int icount=0;
	while (m_isize)
	{
		icount=icount%index;
		if (icount==index-1)
		{
			q->m_next= p->m_next;
			cout<<"YSFdel text:"<<p->m_node<<endl;
			
			delete p;
			p=q->m_next;
			icount=0;
			m_isize--;
		}
		else
		{
			q=p;
			p=p->m_next;
			icount++;
		}
		
	}
	m_prear=NULL;

}
template <typename TypeName>
void CircleList<TypeName>:: delList(int index)
{
	if (index>=m_isize)
	{
		 cout<<"del err:"<<endl;
		return ;// NULL;
	}
	node<TypeName>*p=  m_prear->m_next;
	node<TypeName>*q=m_prear;
		node<TypeName>*TempNode=NULL;
		;
	int ipos=0;
	while (m_prear!=p)
	{
       if (index==ipos)
       {

		  q->m_next= p->m_next;
		  cout<<"del text:"<<p->m_node<<endl;
		  delete p;
		   
		   break;
       }
	   q=p;
	   p=p->m_next;
	   ipos++;
	}
	if (m_prear==p)
	{
		 cout<<"del text:"<<p->m_node<<endl;
		if(q->m_next!= p->m_next)
		     q->m_next= p->m_next;
		else
			m_prear=NULL;
		delete p;
	}
	m_isize--;
	/*if (m_prear!=NULL)
	{
		return  (q->m_next);
	}*/
	
}
//定义参数  返回值 类的实例化 ：：成员函数
template <typename TypeName>
void  CircleList<TypeName>::addTail(node<TypeName> element)
{
	if (m_prear==NULL)
	{
		m_prear=new node<TypeName>;
		m_prear->m_next=m_prear;
		m_prear->m_node=element.m_node;
		m_isize=1;
		cout<< "rearadd: "<< m_prear <<": "<<m_prear->m_node<<endl;
	}
	else
	{
		node<TypeName>* p=m_prear;
		node<TypeName>*pAdd=new node<TypeName>;
		pAdd->m_node=element.m_node;
		/*while(p->m_next!=m_prear)
		{
			p=p->m_next;
		}*/
		pAdd->m_next=p->m_next;
		m_prear->m_next=pAdd;
		
		m_prear=pAdd;
		m_isize++;
		cout<< "rearadd :"<<m_prear <<" :"<<m_prear->m_node<<endl;
	}
}
//定义参数  返回值 类的实例化 ：：成员函数
template <typename TypeName>
void  CircleList<TypeName>::inserList(int index,node<TypeName> element)
{
	if(index>=m_isize)
	{
		cout<<"inster err"<<endl;
		return;
	}
	node<TypeName>* p=m_prear;
	
	node<TypeName>* pNew=new node<TypeName>();
	int ipos=0;

	while (p->m_next!=m_prear)
	{
		if (ipos==index )
		{
			pNew->m_node=element.m_node;
			pNew->m_next=p->m_next;
			p->m_next=pNew;
			
		}
		ipos++;
		p=p->m_next;
	}
	p->m_next=m_prear;
	m_isize++;
}
//定义参数  返回值 类的实例化 ：：成员函数
template <typename TypeName>
void  CircleList<TypeName>:: showList()
{
	if (m_prear==NULL)
              return;
	node<TypeName>* p=m_prear->m_next;
	while(p!=m_prear)
	{
		cout<<p->m_node<<", ";
		p=p->m_next;
		
	}
	cout<<p->m_node;
	cout<<endl;
}
void main()
{
	{
		node<int> as;
		as.m_node=3;
		node<int> as1;
		as1.m_node=4;
		node<int> as2;
		as2.m_node=5;
		node<int> as3;
		as3.m_node=6;
		node<int> as4;
		as4.m_node=7;
        CircleList<int > awe;
		awe.addTail(as);
		awe.addTail(as1);
		awe.addTail(as2);
		awe.addTail(as3);
		awe.addTail(as4);
		awe.showList();
		for (;awe.getSize()>0;)
		{
			awe.delList(0);
		}
		cout<<"约瑟夫问题循环链表解法"<<endl;
		node<int> as_arr[N];
		for (int j=0;j<N;j++)
		{
			as_arr[N].m_node=j+1;
			awe.addTail(as_arr[N]);
		}
		awe.showList();
		awe.YSF(N,3);
	
		
		
	}
	/*{
		node<int> as;
		as.m_node=3;

		node<int> as1;
		as1.m_node=4;
		node<int> as2;
		as2.m_node=5;
		node<int> as3;
		as3.m_node=6;
		node<int> as4;
		as4.m_node=7;
		CircleList<int > awe;
		awe.addTail(as);
		awe.addTail(as1);
		awe.addTail(as2);
		awe.addTail(as3);
		awe.addTail(as4);
		awe.showList();
		cout<<"*******add finish*********"<<endl;
		as.m_node=23;
		awe.inserList(0,as);
		awe.showList();
		as.m_node=24;
		awe.inserList(1,as);
		awe.showList();
		as.m_node=25;
		awe.inserList(2,as);
		awe.showList();
		as.m_node=26;
		awe.inserList(3,as);
		awe.showList();
		as.m_node=30;
		awe.inserList(7,as);
		awe.showList();
	}*/
	system("pause");
}