单向链表C#的实现----以面向对象的思维理解数据结构的构建

1. 为什么要使用单向链表？     

      首先，单向链表的删除非常方便，如果你的程序设计中，需要对数据删除操作频率高，那么，以单向链表作为数据结构是一个不错的选择。链表的删除操作只是需要删除的位置删除数据，不需要对该位置后面的元素一一移位，这样大大提高了删除操作的效率；插入操作同样的，由于是非顺序非连续的存储结构，链表在插入时的复杂度是O(1)，仅需创建一个节点修改该位置处的指针关系，而数组结构的复杂度在O(n)，同时，如果数组的容量达到一个限度的时候，会触发扩容操作。

      然而，尽管链表的删除和插入操作比数字结构的效率高，但是索引一个链表上的数据的开销要比数组结构的要大，前者是O(logn)的复杂度，后者仅是O(1)。我们在程序设计的时候，需要按照我们自己的需求来创建，世上就没有十全十美的事物。

      2.单向链表的代码实现（C#）

分析

                                 

链表的存储形式不像数组，需要连续的内存地址，链表中每个元素的内存地址可以是分散的。无序的，这就需要在每个data 中额外存储一个指向它的下一个data地址的变量：next，以获取链表中的每个元素。

我们称data和next组成的这个数据结构为一个“节点”，是这个节点有最基本的两个字段。

下面开始构造链表的属性和行为。

一个链表有头信息 Head，表示自己长度的信息 Length等属性；

链表的行为有索引元素、在尾部添加元素、任意位置插入元素、删除指定位置上的元素、获取某个位置的元素、计算元素在表的位置等。

// 这是链表中，单个数据节点的父类，T 是用来确定数据类型的参数，类的固定书写格式
public class LoopLinkNode<T> where T : object
{
    private T data;// 节点的数据域，
    private LoopLinkNode<T> next; // 该节点的下一个节点（指针域）

    public T Data 
    {
        set { data = value; }
        get { return data; }
    }
    public LoopLinkNode<T> Next
    {
        set { next = value; }
        get { return next; }
    }

    // 构造函数，节点的创建
    public LoopLinkNode(T data)
    {
        this.data = data;
        next = null;
    }
}

    // 这是链表的父类，链表的属性、字段、行为都在这里定义
    public class LoopLink<T> where T : object
    {
        // 链表的构造函数，在 new 的时候调用，这里创建了一个空的链表，head 节点为空
        public LoopLink()
        {
            this.head = null;            
        }

        // 链表的头信息属性
        private LoopLinkNode<T> head;
        public LoopLinkNode<T> Head
        {
            set
            {
                head = value;
                head.Next = head;
            }
            get { return head; }
        }

        // 链表的长度属性
        public int Length { get { return GetLength(); } }

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public LoopLinkNode<T> this[int index]
        {
            set
            {
                if (IsEmpty())
                    throw new Exception("链表为空");
                if (index < 0 || index > this.Length - 1)
                    throw new Exception("索引超出链表长度");
                LoopLinkNode<T> node = head;
                for (int i = 0; i < index; i++)
                {
                    node = node.Next;                    
                }
                node.Data = value.Data;
                node.Next = value.Next;
            }
            get
            {
                if (IsEmpty())
                    throw new Exception("链表为空");
                if (index < 0 || index > this.Length - 1)
                    throw new Exception("索引超出链表长度");
                LoopLinkNode<T> node = head;
                for (int i = 0; i < index; i++)
                {
                    node = node.Next;                    
                }
                return node;
            }
        }

        /// <summary>
        /// 获取链表长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            if (IsEmpty())
                return 0;
            int length = 1;
            LoopLinkNode<T> temp = head;
            while (temp.Next != head)
            {
                temp = temp.Next;
                length++;
            }
            return length;
        }

        /// <summary>
        /// 清空链表所有元素，只需要将 头信息置空即可
        /// </summary>
        public void Clear()
        {
            this.head = null;
        }

        /// <summary>
        /// 检查链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            if (head == null)
                return true;
            return false;
        }

        /// <summary>
        /// 检查链表是否已满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            return false;
        }

        /// <summary>
        /// 在链表的最末端添加一个新项
        /// </summary>
        /// <param name="item"></param>
        public void Append(T item)
        {
            if (IsEmpty())
            {
                this.Head = new LoopLinkNode<T>(item);
                return;
            }
            LoopLinkNode<T> node = new LoopLinkNode<T>(item);
            LoopLinkNode<T> temp = head;
            while (temp.Next != head)
            {
                temp = temp.Next;
            }
            temp.Next = node;
            node.Next = head;
        }

        /// <summary>
        /// 在链表的指定位置添加一个新项
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void Insert(T item, int index)
        {
            if (IsEmpty())
                throw new Exception("数据链表为空");
            if (index < 0 || index > this.Length)
                throw new Exception("给定索引超出链表长度");
            LoopLinkNode<T> temp = new LoopLinkNode<T>(item);
            LoopLinkNode<T> node = head;
            if (index == 0)
            {
                while (node.Next != head)
                {
                    node = node.Next;
                }
                node.Next = temp;
                temp.Next = this.head;
                return;
            }
            for (int i = 0; i < index - 1; i++)
            {
                node = node.Next;
            }
            LoopLinkNode<T> temp2 = node.Next;
            node.Next = temp;
            temp.Next = temp2;
        }

        /// <summary>
        /// 删除链表指定位置的项目
        /// </summary>
        /// <param name="index"></param>
        public void Delete(int index)
        {
            if (IsEmpty())
                throw new Exception("链表为空，没有可清除的项");
            if (index < 0 || index > this.Length - 1)
                throw new Exception("给定索引超出链表长度");
            LoopLinkNode<T> node = head;
            if (index == 0)
            {
                while (node.Next != head)
                {
                    node = node.Next;
                }
                this.head = head.Next;
                node.Next = this.head;
                return;
            }
            for (int i = 0; i < index - 1; i++)
            {
                node = node.Next;
            }
            node.Next = node.Next.Next;
        }

        /// <summary>
        /// 获取链表指定位置的元素的值
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetItem(int index)
        {
            if (index < 0 || index > this.Length - 1)
                throw new Exception("索引超出链表长度");
            LoopLinkNode<T> node = head;
            for (int i = 0; i < index; i++)
            {
                node = node.Next;
            }
            return node.Data;
        }

        /// <summary>
        /// 根据给定的值查找链表中哪个元素为这个值，如果链表中存在两个元素值相同，则取排在链表前面的元素
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            if (IsEmpty())
                throw new Exception("链表为空");
            LoopLinkNode<T> node = head;
            int index = 0;
            while (node.Next != head)
            {
                if (node.Data.Equals(value))
                    return index;
                else
                    index++;
                node = node.Next;
            }
            if (node.Data.Equals(value))
                return index;
            else
                return -1;
        }
}

测试代码：

    private void Start()
    {
        LoopLink<Vector2> linkList = new LoopLink<Vector2>();
        for (int i = 0; i < 10; i++)
        {
            linkList.Append(new Vector2(i, i % 2));
        }
        Debug.Log("原始数据：");
        for (int i = 0; i < linkList.Length; i++)
        {
            Debug.Log(linkList[i].Data);
        }
        Debug.Log("在倒数第二个的位置处插入元素 (999, 999) 后：");
        linkList.Insert(new Vector2(999, 999), linkList.Length - 2);
        for (int i = 0; i < linkList.Length; i++)
        {
            Debug.Log(linkList[i].Data);
        }
        linkList.Delete(linkList.Length - 1);
        Debug.Log("删除最后一个元素：");
        for (int i = 0; i < linkList.Length; i++)
        {
            Debug.Log(linkList[i].Data);
        }
        Debug.Log("取出第2个元素是： " + linkList.GetItem(1));
        Debug.Log("(0,0)元素在链表中的索引是：" + linkList.Locate(Vector2.zero));
    }

测试结果：