链表

链表是一种物理上非连续、非顺序的存储结构，数据元素之间的顺序是通过每个元素的指针关联的。链表可以用来作为实现栈、队列等数据结构的基础。

        链表有一系列节点组成，每个节点一般至少会包含两部分的信息:(1)元素数据 (2)指向下一个元素的指针

        链表分类: (1)单向链表和双向链表  (2)静态链表(数组实现) 、动态链表(指针)

        链表的操作: 创建、插入、删除、输出

        链表的特点:

        (1)物理空间不连续，空间开销更大

        (2)在运行时可以动态添加

        (3)查找元素需要顺序查找

         动态链表的实现代码如下: 

namespace LinkedList
{
    class Node<T>
    {
        public T Data { get; set; }
        public Node<T> Next { get; set; }
        public Node() {

        }
        public Node(T obj) {
            this.Data = obj;
        }
        public override string ToString()
        {
            return Data.ToString();
        } 
    }
}

using System; 

namespace LinkedList
{
    class LinkedList<T>
    {
        private Node<T> head;
        public int count { get; private set; }
        public LinkedList()
        {
        }
        public LinkedList(T _head) {
            this.head = new Node<T>(_head);
        }
        //添加元素
        public virtual void Add(T value) {
            Node<T> newNode = new Node<T>(value);
            if (this.head == null)
            {
                this.head = newNode;
            }
            else {
                Node<T> lastNode = GetByIndex(count-1);
                lastNode.Next = newNode;
            }
            count++;
        } 
        //索引器
        public T this[int index] {
            get {
                return GetByIndex(index).Data;
            }
            set {
                GetByIndex(index).Data = value;
            }
        }
        //查找指定索引的元素
        private Node<T> GetByIndex(int index) {
            if (index < 0 || index >= this.count) {
                throw new ArgumentOutOfRangeException("index","索引超出范围");
            }
            Node<T> tempNode = this.head;
            for (int i = 0; i < index; i++)
            {
                tempNode = tempNode.Next;
            }
            return tempNode;
        }

        public virtual void Insert(int index, T value) {
            Node<T> newNode = new Node<T>(value);       //新节点
            //如果在开始位置插入
            if (index == 0)
            {
                if (this.head == null)
                {
                    this.head = newNode;
                }
                else
                {
                    newNode.Next = head;
                    this.head = newNode;
                }
            }
            else {
                Node<T> prevNode = GetByIndex(index - 1);       //查找插入点的前驱节点
                Node<T> nextNode = prevNode.Next;               //插入点的后继节点
                prevNode.Next = newNode;        //前驱节点的后继节点为新节点
                newNode.Next = nextNode;        //新节点的后继几点指向原来的前驱的后继
            }
            count++;
        }
        //根据索引删除元素
        public virtual void RemoveAt(int index) {
            //删除头结点
            if (index == 0)
            {
                if (this.head == null)
                {
                    throw new ArgumentOutOfRangeException("index", "索引超出范围");
                }
                this.head = head.Next;
            }
            else {
                //查找删除节点的前驱节点
                Node<T> prevNode = GetByIndex(index-1);
                if (prevNode.Next == null) {
                    throw new ArgumentOutOfRangeException("index","索引超出范围");
                }
                prevNode.Next = prevNode.Next.Next;
            }
            count--;
        }

        public override string ToString()
        {
            string s = "";
            Node<T> temp = head;
            while(temp != null) { 
                s += temp.ToString() + " ";
                temp = temp.Next;
            }
            return s;
        }
    }
}

using System; 
namespace LinkedList
{
    class Program
    {
        static void Main(string[] args)
        {
            LinkedList<int> lst = new LinkedList<int>();
            lst.Add(0);   //添加
            lst.Add(1);
            lst.Add(2);
            lst.Add(3);
            lst.Insert(2,50);    //插入
            Console.WriteLine(lst.ToString());    // 0 1 50 2 3
            lst.RemoveAt(1);        //删除
            lst[2] = 9;     //访问
            Console.WriteLine(lst.ToString());   //0 50 9 3

            Console.ReadKey();
        }
    }
}