第六节：手撸“循环链表”及约瑟夫问题的解决

1. 约瑟夫问题

　　加斯帕·蒙日是法国数学家，他在《数学的游戏问题》中讲了一个故事：15个教徒和15个非教徒在深海上遇险，必须将一半的人投入海中，其余人才能幸免于难，于是想了一个方法，30个人 围城一圈，从第一个人开始依次报数，每数到第九个的人就将他扔向大海，如此循环进行直到仅剩余15个人为止。问怎样的排法，才能使每次投入大海的都是非教徒？这就是著名的约瑟夫问题，又称约瑟夫环。 

　　我们将问题进行一下抽象：N个人进行手尾排列，从第一个开始数数，数到第X个停止，然后把第X个剔除；然后接着数，数到第X个停止，并将其移除，以此类推，直到达到要剔除的个数数目，把这些剔除位置的记录下来，就是我们所需要的位置。很显然，循环链表非常适合解决这个问题。

2. 解决思路

(1). 先抽象出一个单向的循环链表，要有尾节点，尾节点指向头节点；可以用当前节点的前驱节点来表示当前节点。

 代码如下：

 节点

    /// <summary>
    /// 循环链表节点
    /// </summary>
    public class CircleNode<T>
    {
        /// <summary>
        /// 存放数据
        /// </summary>
        public T Data { get; set; }

        /// <summary>
        /// 下一个节点
        /// </summary>
        public CircleNode<T> Next { get; set; }

        public CircleNode()
        {
                
        }

        public CircleNode(T data)
        {
            Data = data;
        }
    }

循环链表

 /// <summary>
    /// 手写单链表
    /// </summary>
    public class MySingleLinkedList<T>
    {
        private Node<T> _header;  //头结点
        private int _count;  //元素个数
        public MySingleLinkedList()
        {

        }
        public MySingleLinkedList(T data)
        {
            _header = new Node<T>(data);
            _count++;
        }
        //只能读
        public int Count
        {
            get
            {
                return _count;
            }       
        }
        /// <summary>
        /// 根据索引获取元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public Node<T> GetNodeByIndex(int index)
        {
            if (index < 0 || index>=_count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            Node<T> tempNode = _header;
            //当index为0的时候，不进入for循环
            for (int i = 0; i < index; i++)
            {
                tempNode = tempNode.Next;
            }
            return tempNode;
        }

        //索引器获取和设置数据
        public T this[int index]
        {
            get
            {
                return GetNodeByIndex(index).Data;
            }
            set
            {
                GetNodeByIndex(index).Data = value;
            }
        }

        /// <summary>
        /// 添加元素(最后)
        /// </summary>
        /// <param name="data"></param>
        public void Add(T data)
        {
            Node<T> newNode = new Node<T>(data);
            if (_header==null)  //表示添加的是第一个节点
            {
                _header = newNode;
            }
            else
            {
                var lastNode = GetNodeByIndex(_count - 1);
                lastNode.Next = newNode;
            }       
            _count++;
        }

        /// <summary>
        /// 插入元素
        /// </summary>
        /// <param name="index">索引</param>
        /// <param name="data">数据</param>
        public void Insert(int index,T data)
        {
            if (index < 0||index>_count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            var newNode = new Node<T>(data); //新节点
            if (index==0)
            {
                //头结点为空，直接插入头结点即可
                if (_header==null)
                {
                    _header = newNode;
                }
                //头结点有元素，需要把头结点的位置让出来
                else
                {
                    newNode.Next = _header;
                    _header = newNode;
                }
            }
            else
            {
                var preNode = GetNodeByIndex(index-1);  //查找插入位置的前驱节点
                var nextNode = preNode.Next;            //插入位置的后继节点
                preNode.Next = newNode;        //前驱结点的后继节点为新节点
                newNode.Next = nextNode;       //新节点的后继节点执行原来前驱的后继
            }
            _count++;             
        }

        /// <summary>
        /// 根据索引删除元素
        /// </summary>
        /// <param name="index">索引</param>
        public void RemoveAt(int index)
        {
            if (index < 0 || index >= _count)
            {
                throw new ArgumentOutOfRangeException("索引越界");
            }
            if (index==0)  //删除头结点
            {
                if (_header==null)
                {
                    throw new ArgumentOutOfRangeException("索引越界");
                }
                _header = _header.Next;
            }
            else
            {
                var preNode = GetNodeByIndex(index - 1); //删除节点的前驱节点
                if (preNode.Next==null)
                {
                    throw new ArgumentOutOfRangeException("索引越界");
                }
                preNode.Next = preNode.Next.Next;     //如果删除的是最后一个节点，那么它的前一个节点指向null
            }
            _count--;
        }
        /// <summary>
        /// 元素输出
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string s = "";
            Node<T> temp = _header;
            while (temp != null)
            {
                s += temp.ToString() + " ";
                temp = temp.Next;
            }
            return s;
        }

    }

测试链表

 {
                MyCircleLinkedList<int> cList = new MyCircleLinkedList<int>();
                cList.Add(1);
                cList.Add(2);
                cList.Add(3);
                cList.Add(4);
                cList.Add(5);
                cList.Add(6);
                cList.Add(7);
                Console.WriteLine($"当前节点值为:{cList.currentNodeValue}");
                cList.Move(2);
                Console.WriteLine($"当前节点值为:{cList.currentNodeValue}");
                cList.RemoveCurrentNode();
                cList.Move(3);
                Console.WriteLine($"当前节点值为:{cList.currentNodeValue}");
                var str1 = cList.ToString();
                Console.WriteLine(str1);
                Console.ReadKey();
            }

运行结果：

(2). 利用循环链表的环解决该问题, 需要记录当前节点，默认当前节点为第一个，所以它的前驱节点为尾节点，然后设计移动算法，将当前节点移动n步，然后删除当前节点，那么下一个节点就变为当前节点了，然后接着移动，直到人数符合要求为止。

 {
                MyCircleLinkedList<int> cList = new MyCircleLinkedList<int>();
                string result = string.Empty;
                Console.WriteLine("请输入总人数：");
                int count = int.Parse(Console.ReadLine());
                Console.WriteLine("请输入出队的位置：");
                int outPosition = int.Parse(Console.ReadLine());
                Console.WriteLine("请输入出队的个数：");
                int outPerson = int.Parse(Console.ReadLine());

                Console.WriteLine("游戏开始");
                for (int i = 1; i <= count; i++)
                {
                    cList.Add(i);
                }
                Console.WriteLine($"所有人的人：{cList.ToString()} ");
                //此处的业务用来表示剩下多少个人
                while (cList.Count > (count - outPerson))
                {
                    //移动的步数=位置数-1
                    cList.Move(outPosition-1);
                    result += cList.currentNodeValue.ToString() + " ";
                    cList.RemoveCurrentNode();      //删掉当前节点出队
                    if (cList.Count == (count - outPerson))
                    {
                        Console.WriteLine($"剩余的人为：{cList.ToString()} ");
                    }
                    else
                    {
                        Console.WriteLine($"剩余的人为：{cList.ToString()} 开始报数的人为：{cList.currentNodeValue.ToString()} ");
                    }

                }
                Console.WriteLine("出队位置的顺序： " + result);
            } 

运行结果：

 

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。