数据结构---循环单链表

循环链表

循环链表是一种链式存储结构，它的最后一个结点指向头结点，形成一个环。因此，从循环链表中的任何一个结点出发都能找到任何其他结点。循环链表的操作和单链表的操作基本一致，差别仅仅在于算法中的循环条件有所不同。

 

具体代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DDataStructures
{
    internal class RListNode<T>
    {
        public T value;

        public RListNode<T> next;

        public RListNode()
        {
            this.next = null;
        }

        public RListNode(T value)
            : this()
        {
            this.value = value;
        }
 
    }

    public class RLinkList<T>
    {
        private RListNode<T> m_Head;
        private RListNode<T> m_End;

        private int m_Count;

        public RLinkList()
        {
            m_Head = new RListNode<T>();
            m_Head.next = m_Head;
            m_End = m_Head;
            m_End.next = m_Head;
            m_Count = 0;
        }

        EqualityComparer<T> m_Comparer = EqualityComparer<T>.Default;

        public bool IsEmpty { get { return m_Head.next == null; } }

        public void MakeEmpty()
        {
            m_Head.next = m_Head;
            m_Count = 0;
        }

        private RListNode<T> Find(T item, out int index)
        {
            RListNode<T> current = m_Head.next;
            index = 0;
            while (current != null && !m_Comparer.Equals(item, current.value))
            {
                current = current.next;
                index++;
            }
            if (current == null) index = -1;
            return current;
        }

        private RListNode<T> FindPrevious(T item)
        {
            RListNode<T> current = m_Head;
            while (current.next != null && !m_Comparer.Equals(item, current.next.value))
            {
                current = current.next;
            }
            return current;
        }


        public void Add(T item)
        {
            RListNode<T> current = new RListNode<T>(item);
            m_End.next = current;
            current.next = m_Head;
            m_End = current;
            m_Count++;
        }

        public void Insert(int index, T item)
        {
            if (index < 0 || index >= this.m_Count)
                throw new ArgumentOutOfRangeException("index", index, "index value is out of range,please check!");

            RListNode<T> current = this.m_Head;
            RListNode<T> node = new RListNode<T>(item);
            while (index-- > 0) current = current.next;
            node.next = current.next;
            current.next = node;

            if (m_End.next != null) m_End = node;
            m_Count++;
        }

        public void Remove(T item)
        {
            RListNode<T> p = FindPrevious(item);
            if (p.next != null)
            {
                p.next = p.next.next;
                m_Count--;
            }
        }


        public void PrintList()
        {
            RListNode<T> current = m_Head;
            while (current.next != m_Head)
            {
                Console.WriteLine(current.next.value);
                current = current.next;
            }
        }

        public T Move(int step)
        {
            RListNode<T> current = m_Head;
            RListNode<T> temp;
            while (step-- > 0)
            {
                if (current.next == m_Head)
                    current = current.next;
                current = current.next;
            }
            temp = current;
            return temp.value;
        }

        public void Print(int step)
        {
            RListNode<T> current = this.m_Head;
            while (step-- > 0)
            {
                if (current.next == m_Head)
                    current = current.next;
                Console.WriteLine(current.next.value);
                current = current.next;
            }
        }
    }
}