C#双向链表

前几日我朋友跟我吐槽C#的数组往上追溯并处理数据不方便，然后我就想起了我很久没用过链表，因此今天下午抽了点时间写了一个双向链表以后想用的时候自己可以拿来用,这里我写的是尾插法，如果忽略tail节点，它还是个循环双向链表。

链表与数组不一样，数组能快速查找数据，但是插入和删除不方便，而链表在指定位置插入或者删除都是非常方便的，但是对于查找特定数据则比较麻烦

/// <summary>
/// 链表节点的基本结构
/// </summary>
/// <typeparam name="T"></typeparam>
public class Node<T>
{
    /// <summary>
    /// 数据
    /// </summary>
    public T data { get; set; }

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

    /// <summary>
    /// 上一个节点
    /// </summary>
    public Node<T> pre { get; set; }
    public Node()
    {
        data = default(T);
        next = null;
        pre = null;
    }
    public Node(T model)
    {
        this.data = model;
        this.pre = this;
        this.next = this;
    }
}

/// <summary>
/// 链表的处理类
/// </summary>
/// <typeparam name="T"></typeparam>
public class NodeList<T>
{
    /// <summary>
    /// 链表长度
    /// </summary>
    private int length { get; set; }

    /// <summary>
    /// 链表长度
    /// </summary>
    public int Length { get { return length; } }
    private Node<T> tail;
    public NodeList()
    {
        length = 0;
        tail = new Node<T>();
        tail.next = tail;
        tail.pre = tail;
    }
    public NodeList(T model)
    {
        tail = new Node<T>();
        Node<T> n = new Node<T>(model);
        length = 1;
        tail.pre = n;
        tail.next = n;
        n.pre = tail;
        n.next = tail;
    }

    /// <summary>
    /// 在链表末端插入节点
    /// </summary>
    /// <param name="model"></param>
    public void InsertNode(T model)
    {
        Node<T> n = new Node<T>(model);

        n.next = tail;
        n.pre = tail.pre;

        tail.pre.next = n;
        tail.pre = n;
        length++;
    }

    /// <summary>
    /// 在指定位置插入节点
    /// </summary>
    /// <param name="model"></param>
    /// <param name="pos"></param>
    /// <returns></returns>
    public bool InsertNode(T model, int pos)
    {
        if (pos > length)
        {
            return false;
        }
        else
        {
            Node<T> n = new Node<T>(model);
            Node<T> temp = tail;
            for (int i = 0; i < pos; i++)
            {
                temp = temp.next;
            }
            n.next = temp.next;
            temp.next = n;
            length++;
            return true;
        }
    }

    /// <summary>
    /// 删除指定节点
    /// </summary>
    /// <param name="pos"></param>
    /// <returns></returns>
    public bool RemoveNode(int pos)
    {
        if (pos > length)
        {
            return false;
        }
        else
        {
            Node<T> temp = tail;
            for (int i = 0; i < pos; i++)
            {
                temp = temp.next;
            }
            temp.next.pre = temp.pre;
            temp.pre.next = temp.next;
            length--;
            return true;
        }
    }

    /// <summary>
    /// 输出数据
    /// </summary>
    public void ConsoleWrite()
    {
        Node<T> temp = tail;
        for (int i = 0; i < length; i++)
        {
            temp = temp.next;
            Console.WriteLine("第{0}个数据是：{1}；", i, temp.data);
        }
    }
}


        static void Main(string[] args)
        {
            NodeList<int> list = new NodeList<int>();
            list.InsertNode(1);
            list.InsertNode(2);
            list.InsertNode(3);
            list.InsertNode(4);
            list.InsertNode(5);
            list.InsertNode(6);
            list.InsertNode(7,1);
            list.InsertNode(8,1);
            list.RemoveNode(5);
            list.ConsoleWrite();


            Console.ReadLine();
        }

输出结果如下：

第0个数据是：1；
第1个数据是：8；
第2个数据是：7；
第3个数据是：2；
第4个数据是：4；
第5个数据是：5；
第6个数据是：6； 

 插入的时候，先将新节点指向下一节点，再将上一结点的尾部指向新节点。

 

大概就是这个意思，PS画图太麻烦了，就不继续画了