自己动手实现一个C#中List

文章在我的游戏蛮牛博客中：http://www.unitymanual.com/blog-23965-2466.html?_dsign=b0a4d01a

C#中的IList用着挺舒服的，非常容易上手，但是最近被问到内部是怎么实现的，我也不知道！

.net内部是怎么实现的我是不知道的。但是学过数据结构的，都知道链表是怎么回事的，不知道的可以问问度娘，一会儿就知道了。

道理都是想通的，只是不同的平台实现的方式不同。其实，就算懂或者不懂，对工作什么的也没啥重要的，会用就行。只是了解了原理，有助于我们更好的运用。

以前用C++写的时候用指针，非常方便。虽然C#中没有指针，但是，你可以把引用类型当做指针。

没学过C或者C++，不知道啥是指针的把上一行当做空气，不影响。

现在就动手用C#做一个泛型的List：

需要一个节点，存储你要保持的值，因为不知道你要存储的值的内容，所以用泛型。

    public class Node <T>
    {
        public T t {get; set;}
        public Node<T> node {get; set;} //对自身的引用
        public void Display()
        {
            Console.WriteLine(this.t);
        }
    }

Node中T是你要存入的数据的类型，t是具体数据；

还需要另一个类，用来对节点进行操作：

    public class MyList <T>
    {
        public int Length { get; set; }

        public Node<T> Rear { get; set; }

        public Node<T> Head { get; set; }

        public Node<T> Temp { get; set; }

        public MyList()
        {
            this.Length = 0;
            this.Head = null;
            this.Rear = null;
            this.Temp = null;
            this.Head = this.Rear;
        }

        public void Clear()
        {
            while (this.Head != null)
            {
                this.Rear = this.Head.node;
                this.Head.node = null;
                this.Head = null;
                this.Head = this.Rear;
                Length --;
            }
            Console.WriteLine("长度 " + Length);
            GC.Collect();
        }

        public void Add(T t) //添加元素
        {
            Node<T> NODE = new Node<T>();
            NODE.t = t;
            NODE.node = null;

            if (Head == null)
            {
                Rear = NODE;
                Head = Rear;
                Length ++;
                return;
            }
            Rear.node = NODE;
            Rear = Rear.node;
            this.Length++;
        }

        public void Insert(T value, int index)
        {
            if (index > Length)
            {
                Console.WriteLine("插入失败，你所插入的位置不存在");
            } else
            {
                Node<T> NODE = new Node<T>();
                NODE.t = value;
                NODE.node = null;
                if (0 == index)
                {
                    NODE.node = Head;
                    Head = NODE;
                    this.Length ++;
                } else
                {
                    Temp = Head;
                    int i = 0;
                    while (i < index - 1)
                    {
                        Temp = Temp.node;
                        i++;
                    }
                    NODE.node = Temp.node;
                    Temp.node = NODE;
                    this.Length ++;
                }
            }

        }
//转置操作，将内部元素反转
        public void Reverse() 
        {
            Node<T> t = new Node<T>();
            while(Head != this.Rear)
            {
                Temp = Head;
                Head = Head.node;
                Temp.node = null;
                t = this.Rear.node;
                this.Rear.node = Temp;
                Temp.node = t;
            }
        }

        public int Contains(T t) //查找元素是否存在
        {
            int i = -1;
            int j = 0;
            Temp = Head;
            while(Temp != null)
            {
                if(t.ToString() == Temp.t.ToString())
                {
                    i = j;
                }
                Temp = Temp.node;
                j ++;
            }
            return i;
        }

        public void Display()
        {
            Console.WriteLine("总数是：" + this.Length);
            Temp = this.Head;
            while (Temp != null)
            {
                Temp.Display();
                Temp = Temp.node;
            }
            Temp = null;
        }
    }

在主函数中调用

        public static void Main(string[] args)
        {
            MyList<int> arr = new MyList<int>();

            arr.Add(1);
            arr.Add(2);
            arr.Add(3);
            arr.Add(4);
            arr.Insert(99,3);
            arr.Display();
            arr.Reverse();
            arr.Display();
            MyList<string> str = new MyList<string>();
            str.Add("str1");
            str.Add("str2");
            str.Display();
        }

结果：

具体原理，就是数据结构中的链表。

至于.net内部的泛型List，跟这个实现原理还不太一样，.net内是维护一个数组存储元素，类似于数据结构中的线性表。 而，我的做法是使用链表，想了解详情自己查看详细资料。

仅供参考，学习交流，如有BUG，请不要声张！谢谢！