c++实现循环链表并解决约瑟夫问题

1、单向循环链表的特点：

• 单向循环链表的特点与单向链表十分相似，唯一的区别是循环链表是首尾相连的
• 其具体的形式如下

 

循环链表的实现主要是看怎么将首尾相连表现出来。

2、循环链表定义：

其定义与单向链表相似，是一个定义节点和list的过程：

• 定义节点和链表：

 

class cycle_node//定义节点
{
public:
        int data;
        cycle_node* next;
};
class cycle_list//定义循环链表
{
public:
        cycle_node* head;
        int size;
};

　　

• 循环链表的初始化

初始化的时候是将链表的尾指针指向头节点，这个操作与单向链表的不一样 

 

cycle_list* cycle_list_init()//定义一个长度为零的循环链表
{
        cycle_list* CL = new cycle_list;
        CL->size = 0;
        CL->head = new cycle_node;//记得这里的将头指针指向new出来的一个节点
        CL->head->next = CL->head;//这部操作十分重要
        CL->head->data = NULL;
        return CL;
}

 

• 循环链表的指定位置元素添加

 

void cycle_list_insert(cycle_list* CL,int pos,int data)
{
        cycle_node* new_node = new cycle_node;
        new_node->data = data;
        new_node->next = NULL;
        cycle_node* pos_node = CL->head;
        for (int i = 0; i < pos; i++)
        {
               pos_node = pos_node->next;
        }
        new_node->next = pos_node->next;
        pos_node->next = new_node;
        CL->size++;
}

 

• 循环链表指定位置的数据删除

void cycle_list_dele(cycle_list* CL,int pos)
{
        if (CL->size == 0)
        {
               cout << "链表为空，无法删除" << endl;
        }
        cycle_node* pos_node = CL->head;
        for (int i = 0; i < pos; i++)
        {
               pos_node = pos_node->next;
        }
        pos_node->next = pos_node->next->next;
        CL->size--;
}

　　

• 打印一个循环链表（打印的时候注意跳过头节点）

 

void cycle_list_printf(cycle_list* CL)
{
        if (CL->size == 0)
        {
               cout << "链表为空" << endl;
        }
        cycle_node* s_node = CL->head->next;
        for (int i = 0; i < CL->size; i++)
        {
               if (s_node == CL->head)
               {
                       s_node = CL->head->next;
               }
               cout << s_node->data << "  ";
               s_node = s_node->next;
               
        }
        cout << endl;
}

　　

• 删除循环链表的某个指定元素

 

void cycle_list_deledata(cycle_list* CL,int data)
{
        cycle_node* s_node = CL->head;
        for (int i = 0; i < CL->size; i++)
        {
               if (s_node->next->data == data)
               {
                       s_node->next = s_node->next->next;
               }
               s_node = s_node->next;
        }
        CL->size--;
}

　　

• 解决约瑟夫问题方法一（定位到指定要删除的节点s_node，用删除元素的方法删除节点）

 

int main()
{
       cycle_list* CL = cycle_list_init();
        for (int i = 0; i < 100; i++)
        {
               cycle_list_insert(CL, i, i + 1);
        }
        cycle_list_printf(CL);
        //开始解决约瑟夫问题方法一
        int index = 0;
        cycle_node* s_node = CL->head->next;
        while (CL->size != 0)
        {       
               for (int i = 0; i < 2; i++)
               {
                       if (s_node == CL->head)
                       {
                              s_node = CL->head->next;
                       }
                       s_node = s_node->next;
                       if (s_node == CL->head)
                       {
                              s_node = CL->head->next;
                       }
               }
               index++;
               cout << "第" << index << "次删除的是" << s_node->data << endl;
               cycle_list_deledata(CL,s_node->data);
               s_node = s_node->next;
        }
}

 

• 解决约瑟夫问题方法二（通过定位到需要删除的前一个节点，让需要删除的节点删除）

 

int main()
{
        cycle_list* CL = cycle_list_init();
            for (int i = 0; i < 100; i++)
            {
                   cycle_list_insert(CL, i, i + 1);
            }
        cycle_list_printf(CL);
//解决方法二
        *int index = 0;
        cycle_node* s_node = CL->head;
        while (CL->size != 0)
        {
               if (s_node == CL->head)
               {
                       s_node = CL->head->next;
               }
               s_node = s_node->next;
               if (s_node == CL->head)
               {
                       s_node = CL->head->next;
               }
               index++;
               if (s_node->next == CL->head)
               {
                       s_node->next = CL->head->next;
               }
               cout << "第" << index << "次删除的是：" << s_node->next->data << endl;
               s_node->next = s_node->next->next;
               s_node = s_node->next;
               CL->size--;
        }
}