双向链表实现约瑟夫环 2016/6/12

今天实现了一个简单的双向链表，用来完成约瑟夫环：

约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后[1]  结果+1即为原问题的解。

其实，vc中有封装好的CList,但是，老用人家封装好的库，挺没意思的，今天就简单的实现了一个双向链表类，说简单，是因为只实现了与解决这次问题相关的函数，其他更多的功能，等以后有时间了再来完善吧

直接上代码：

头文件：

#pragma once

//自己实现双向链表

typedef int DATA;

class Node

{

public:
Node();
DATA data;
Node*pFormer;
Node*pNext;

};

class CRecyleList

{

public:
CRecyleList();
~CRecyleList();
void AddatHead(DATA tData);
void AddatTail(DATA tData);
void Remove(Node*tNode);
void RemoveAll();
//void AddatNode(Node*pNode);
Node*GetHeader();
Node*GetTail();
void Print();

private:
Node*pHeader;
Node*pTail;

};

class KillGame

{

public:
KillGame(int nums);         //构建多少个人的杀人游戏
Node*Start(Node*tNode,int num);//从哪个节点开始 杀人， num报几个数
Node*GetHeader();

private:
CRecyleList m_List;

};

源文件：

#include <iostream>

using namespace  std;

Node::Node()

{
data = 0;
pFormer = 0;
pNext = 0;

}

CRecyleList::CRecyleList()

{
pHeader = 0;
pTail = 0;

}

CRecyleList::~CRecyleList()

{
Node*p = pHeader;
while (p!=pTail)
{
Node*m = p;
p = p->pNext;
delete m;
}
delete pTail;

}

Node* CRecyleList::GetHeader()

{
return pHeader;

}

Node* CRecyleList::GetTail()

{
return pTail;

}

void CRecyleList::AddatHead(DATA tData)

{
Node*pNode = new Node;
pNode->data = tData;

    
if (pHeader != 0)
{
pNode->pNext = pHeader;
pHeader->pFormer = pNode;
pHeader = pNode;
}
else
{
pHeader = pNode;
pTail = pNode;
}

pHeader->pFormer = pTail;
pTail->pNext = pHeader;

}

void CRecyleList::AddatTail(DATA tdata)

{
Node*pNode = new Node;
pNode->data = tdata;

if (pTail!=0)
{
pNode->pFormer = pTail;
pTail->pNext = pNode;
pTail = pNode;
}
else
{
pTail = pNode;
pHeader = pNode;
}
pTail->pNext = pHeader;
pHeader->pFormer = pTail;

}

void CRecyleList::Remove(Node*pNode)

{

if (pNode == pHeader)
{
pHeader = pNode->pNext;
}
if (pNode==pTail)
{
pTail = pNode->pFormer;
}
pNode->pFormer->pNext = pNode->pNext;
pNode->pNext->pFormer = pNode->pFormer;
delete pNode;

}

void CRecyleList::Print()

{
cout << endl;
Node*pNode = pHeader;
Node*m = pHeader;
cout << pNode->data << "    ";
pNode = pNode->pNext;
while (pNode!=m)
{
cout << pNode->data << "   ";
pNode = pNode->pNext;
}
//cout << pTail->data << endl;

}

KillGame::KillGame(int num)

{
for (int i = 0; i < num;i++)
{
//m_List.AddatHead(i);
m_List.AddatTail(i);
}
//m_List.Print();

}

Node* KillGame::Start(Node*tNode, int num)

{
Node*pNode = tNode;

while (pNode!=pNode->pFormer&&pNode!=pNode->pNext)
{
for (int i = 1; i < num;i++)
{
pNode = pNode->pNext;
}
Node*temp = pNode;
pNode = pNode->pNext;
m_List.Remove(temp);
// m_List.Print();
}
return pNode;

}

Node*KillGame::GetHeader()

{
return m_List.GetHeader();

}

main函数：

KillGame game(16);
Node*pHader = game.GetHeader();
Node*pNode=game.Start(pHader, 3);
cout << pNode->data << endl;