基本数据结构（列表、栈、队列、单链表以及双向链表的定义与实现）

interface IList<T>
    {
        /// <summary>
        /// 获取列表长度
        /// </summary>
        /// <returns></returns>
        int GetLength();

        /// <summary>
        /// 清空
        /// </summary>
        void Close();

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="item"></param>
        void Add(T item);

        /// <summary>
        /// 在index位置插入元素item
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        void Insert(T item, int index);

        /// <summary>
        /// 删除index位置的元素
        /// </summary>
        T Delete(int index);

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        T this[int index] { get; }

        /// <summary>
        /// 根据索引得到元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        T GetEle(int index);

        /// <summary>
        /// 根据元素得到索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        int Locate(T value);
    }

然后在类中继承接口并实现接口方法

 class SeqList<T> : IList<T>
    {
        /// <summary>
        /// 用来存储数据
        /// </summary>
        private T[] data;

        private int count = 0;

        public SeqList(int size)
        {
            data = new T[size];
            count = 0;
        }

        public SeqList() : this(5)
        {

        }
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get { return data[index]; }
        }

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            if (data.Length == count)
            {
                Console.WriteLine("当前数组已满");
            }
            else
            {
                data[count] = item;
                count++;
            }
        }

        /// <summary>
        /// 清空
        /// </summary>
        public void Close()
        {
            count = 0;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T Delete(int index)
        {
            T temp = data[index];
            if (index >= 0 && index < count)
            {
                for (int i = index; i < count - 1; i++)
                {
                    data[i] = data[i + 1];
                }
            }
            else
            {
                Console.WriteLine("要删除的数据超出索引");
                return temp;
            }
            count--;
            return temp;
        }

        /// <summary>
        /// 根据索引得到元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            if (index >= 0 && index < count)
            {
                return data[index];
            }
            else
            {
                Console.WriteLine("查找的索引不存在");
                return default(T);
            }
        }

        /// <summary>
        /// 插入数据
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void Insert(T item, int index)
        {
            if (count < data.Length && index >= 0 && index <= count)
            {
                for (int i = count - 1; i >= index; i--)
                {
                    data[i + 1] = data[i];
                }
            }
            else
            {
                Console.WriteLine("超出索引，无法插入");
                return;
            }
            data[index] = item;
            count++;
        }

        /// <summary>
        /// 判断是否等于空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return count == 0;
        }

        /// <summary>
        /// 取得数据的个数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }

        /// <summary>
        /// 根据元素得到索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            for (int i = 0; i < count; i++)
            {
                if (data[i].Equals(value))
                {
                    return i;
                }
            }
            return -1;
        }
    }

普通队列的实现

interface IQueue<T>
    {
        int GetLength();
        bool IsEmpty();
        void Clear();
        void In(T item);
        T Out();
        T GetFront();
    }

 class SeqQueue<T> : IQueue<T>
    {
        private T[] data;
        private int count;
        private int front;//记录取出多少个数据
        private int rear;//记录存入多少个数据

        public int Count
        {
            get { return count; }
        }

        public int Front
        {
            get { return front; }
        }

        public int Rear
        {
            get { return rear; }
        }

        public SeqQueue(int size)
        {
            count = 0;
            data = new T[size];
            front = rear = -1;
        }

        public T this[int index]
        {
            get { return data[index]; }
        }

        /// <summary>
        /// 清除
        /// </summary>
        public void Clear()
        {
            count = 0;
            front = rear = -1;
        }

        /// <summary>
        /// 获取第一个数据
        /// </summary>
        /// <returns></returns>
        public T GetFront()
        {
            return data[front + 1];
        }

        /// <summary>
        /// 获取长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }
        /// <summary>
        /// 判断是否已满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            if (count==data.Length)
            {
                Console.WriteLine("队列已满");
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item"></param>
        public void In(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("队列已满，无法添加");
                return;
            }
            else
            {
                if (rear==data.Length-1)
                {
                    data[0] = item;
                    rear = 0;
                    count++;
                }
                else
                {
                    data[rear + 1] = item;
                    rear++;
                    count++;
                }
            }
        }

        /// <summary>
        /// 是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return count == 0;
        }

        /// <summary>
        /// 取出元素
        /// </summary>
        /// <returns></returns>
        public T Out()
        {
            if (count>0)
            {
                T temp = data[front + 1];
                if (front<data.Length-2)
                {
                    front++;
                }
                else
                {
                    front = -1;
                }
                count--;
                return temp;
            }
            if (count<0)
            {
                Console.WriteLine("队列为空");
                return default(T);
            }
            return default(T);
        }
    }

链表队列的实现：链表队列需要使用节点指针

class Node<T>
    {
        
        private T data;
        private Node<T> next;

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public Node<T> Next
        {
            get { return next; }
            set { next = value; }
        }

        public Node(T value, Node<T> p)
        {
            next = p;
            data = value;
        }

        public Node(T value)
        {
            next = null;
            data = value;
        }

        public Node(Node<T> p)
        {
            next = p;
        }

        public Node()
        {
            next = null;
            data = default(T);
        }
    }

链表队列的实现

class LinkQueue<T> : IQueue<T>
    {
        private Node<T> front;

        private Node<T> rear;
        private int count;

        public int Count
        {
            get { return count; }
        }

        public Node<T> Front
        {
            get { return front; }
            set { front = value; }
        }

        public Node<T> Rear
        {
            get { return rear; }
            set { rear = value; }
        }


        public LinkQueue()
        {
            front = null;
            rear = null;
            count = 0;
        }

        public T this[int index]
        {
            get
            {
                Node<T> temp = front;
                for (int i = 0; i < index; i++)
                {
                    if (temp.Next!=null)
                    {
                        temp = temp.Next;
                    }
                }
                return temp.Data;
            }
        }


        /// <summary>
        /// 清除
        /// </summary>
        public void Clear()
        {
            front = null;
            rear = null;
            count = 0;
        }

        /// <summary>
        /// 得到头节点的数据
        /// </summary>
        /// <returns></returns>
        public T GetFront()
        {
            if (front!=null)
            {
                return front.Data;
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// 判断长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item"></param>
        public void In(T item)
        {
            Node<T> q = new Node<T>(item);
            if (count==0)
            {
                front = q;
                rear = q;
                ++count;
            }
            else
            {
                rear.Next = q;
                rear = q;
                ++count;
            }
        }

        /// <summary>
        /// 判断是否等于空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return count == 0;
        }
        /// <summary>
        /// 取出队列中第一个数据
        /// </summary>
        /// <returns></returns>
        public T Out()
        {
            if (count==0)
            {
                Console.WriteLine("队列为空，无法取出");
                return default(T);
            }
            else if (count==1)
            {
                T temp = front.Data;
                front = null;
                rear = null;
                count = 0;
                return temp;
            }
            else
            {
                T temp = front.Data;
                front = front.Next;
                count--;
                return temp;
            }
        }
    }

普通栈（顺序栈）的使用

public interface IStack<T>
    {
        int GetLength();
        bool IsEmpty();
        void Clear();
        void Push(T item);
        T Pop();
        T GetTop();

    }

 /// <summary>
    /// 顺序栈
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class SeqSrack<T> : IStack<T>
    {
        private int maxsize;
        private T[] data;
        private int top;


        public int MaxSize
        {
            get { return maxsize; }
            set { maxsize = value; }
        }

        public int Top
        {
            get { return top; }
        }

        public SeqSrack(int size)
        {
            data = new T[size];
            maxsize = size;
            top = -1;
        }


        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                if (index>-1&&index<=top)
                {
                    return data[index];
                }
                else
                {
                    Console.WriteLine("索引输入错误，请重新输入");
                    return default(T);
                }
            }
        }


        public void Clear()
        {
            top = -1;
            Array.Clear(data, 0, maxsize);
        }

        /// <summary>
        /// 获取长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return top + 1;
        }

        /// <summary>
        /// 取出顶点的数据
        /// </summary>
        /// <returns></returns>
        public T GetTop()
        {
            if (IsEmpty())
            {
                Console.WriteLine("顺序栈为空");
                return default(T);
            }
            return data[top];
        }

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return top == -1;
        }
        /// <summary>
        /// 顺序栈是否是满的
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            return top == maxsize - 1;
        }
        /// <summary>
        /// 获取栈顶数据
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            T temp = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("顺序栈是空的，无法获取数据");
                return temp;
            }
            temp = data[top];
            top--;
            return temp;
        }

        /// <summary>
        /// 加入数据
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("顺序栈已满，无法加入数据");
                return;
            }
            data[++top] = item;
        }
    }

链栈的使用（注意也需要继承栈的接口）首先定义节点类

 public class Node<T>
    {
        private T data;
        private Node<T> next;

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

        public Node<T> Next
        {
            get { return next; }
            set { next = value; }
        }

        public Node(T value,Node<T> p)
        {
            data = value;
            next = p;
        }

        public Node(Node<T> p)
        {
            next = p;
        }

        public Node(T value)
        {
            data = value;
        }

        public Node()
        {
            data = default(T);
            next = null;
        }

    }

 public class LinkStack<T> : IStack<T>
    {
        private Node<T> top;
        private int num;

        public Node<T> Top 
        {
            get { return top; }
            set { top = value; }
        }

        public int Num
        {
            get { return num; }
        }

        public LinkStack()
        {
            top = null;
            num = 0;
        }


        public T this[int index]
        {
            get
            {
                Node<T> temp = top;
                if (index>=1&&index<=num)
                {
                    for (int i = 1; i < index; ++i)
                    {
                        if (temp.Next!=null)
                        {
                            temp = temp.Next;
                        }
                    }
                    return temp.Data;
                }
                else
                {
                    Console.WriteLine("索引错误，请重新输入");
                    return default(T);
                }
                
            }
        }

        /// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            num = 0;
            top = null;
        }

        /// <summary>
        /// 获取长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return num;
        }

        /// <summary>
        /// 获取栈点的数据
        /// </summary>
        /// <returns></returns>
        public T GetTop()
        {
            if (IsEmpty())
            {
                Console.WriteLine("链栈为空，无法获取栈点数据");
                return default(T);
            }
            return top.Data;
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return top == null && num == 0 ? true : false;
        }

        /// <summary>
        /// 出栈(删除栈点的数据)
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            if (IsEmpty())
            {
                Console.WriteLine("链栈目前为空，无法出栈");
                return default(T);
            }
            else
            {
                Node<T> p = top;
                top = top.Next;
                num--;
                return p.Data;
            }
        }

        /// <summary>
        /// 插入（添加）
        /// </summary>
        /// <param name="item"></param>
        public void Push(T item)
        {
            Node<T> q = new Node<T>(item);
            if (top==null)
            {
                top = q;
            }
            else
            {
                q.Next = top;
                top = q;
            }
            num++;
        }
    }

单链表的定义与实现：首先需要定义接口以及节点类

 interface IListDS<T>
    {
        /// <summary>
        /// 获取长度
        /// </summary>
        /// <returns></returns>
        int GetLength();

        /// <summary>
        /// 清空
        /// </summary>
        void Clear();

        /// <summary>
        /// 根据索引查找元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        //T this[int index] { get; }

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item">要添加的数据</param>
        void Addend(T item);

        /// <summary>
        /// 在某个位置插入元素
        /// </summary>
        /// <param name="item">要插入的元素</param>
        /// <param name="i">在哪个位置</param>
        void Insert(T item, int i);

        /// <summary>
        /// 根据索引删除元素
        /// </summary>
        /// <param name="i">索引</param>
        /// <returns></returns>
        T Delete(int i);

        /// <summary>
        /// 根据索引得到元素
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        T GetEle(int i);

        /// <summary>
        /// 根据值得到索引
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        int Locate(T value);
    }

继续定义节点类

class Node<T>
    {
        private T data;
        private Node<T> next;//引用域，指向下一个对象（指针）

        //中间节点
        public Node(T val, Node<T> p)
        {
            data = val;
            next = p;
        }

        //头节点
        public Node(Node<T> p)
        {
            next = p;
        }

        //尾节点
        public Node(T val)
        {
            data = val;
            next = null;
        }


        public Node()
        {
            data = default(T);
            next = null;
        }


        public T Data
        {
            get { return data; }
            set { data = value; }
        }


        public Node<T> Next
        {
            get { return next; }
            set { next = value; }
        }
    }

下面实现单链表：

//单链表
    class LinkListtest<T> : IListDS<T>
    {

        private Node<T> head;

        public Node<T> Head
        {
            get { return head; }
            set { head = value; }
        }
        //单链表的长度
        private int length;
        public int Length
        {
            get { return length; }
        }
        public LinkListtest()
        {
            head = null;
            length = 0;
        }

        public T this[int index]
        {
            get { return GetEle(index); }
        }


        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="item">要添加的数据</param>
        public void Addend(T item)
        {
            Node<T> q = new Node<T>(item);
            if (head==null)
            {
                head = q;
            }
            else
            {
                Node<T> p = head;
                for (int i = 1; i <= GetLength(); i++)
                {
                    if (p.Next!=null)
                    {
                        p = p.Next;
                    } 
                }
                p.Next = q;
                Console.WriteLine("添加成功，添加的数据为{0}",item);
            }
            length++;
            Console.WriteLine("当前链表长度为{0}",length);
        }

        /// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            head = null;
            length = 0;
        }

        /// <summary>
        /// 根据位置删除
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T Delete(int index)
        {
            if (IsEmpty())
            {
                Console.WriteLine("删除失败，请检查链表是否为空或者索引超出限制");
            }
            if (index==1)
            {
                Node<T> p = head;
                head = head.Next;
                length--;
                return p.Data;
            }
            if (index>1&&index<=GetLength())
            {
                Node<T> temp = head;
                for (int i = 1; i <index-1 ; i++)
                {
                    if (temp.Next!=null)
                    {
                        temp = temp.Next;
                    }
                }
                Node<T> tempForward = temp;
                temp = temp.Next;
                Node<T> tempnext = temp;
                tempForward.Next = tempnext.Next;
                length--;
                return tempnext.Data;
            }
            else
            {
                Console.WriteLine("删除失败，请检查索引、链表是否为空");
                return default(T);
            }
           
        }

        /// <summary>
        /// 根据索引得到元素
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            T data = default(T);
            if (index==1)
            {
                return head.Data;
            }
            if (index>1&&index<=GetLength())
            {
                Node<T> temp = head;
                for (int i = 1; i < index; i++)
                {
                    if (temp.Next!=null)
                    {
                        temp = temp.Next;
                    }
                }
                return temp.Data;
            }
            else
            {
                Console.WriteLine("索引输入错误，请重新输入");
                return data;
            }
        }
        /// <summary>
        /// 获取当前链表的长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return length;
        }

        /// <summary>
        /// 根据位置插入数据
        /// </summary>
        /// <param name="item">要插入的数据</param>
        /// <param name="i">要插入的位置</param>
        public void Insert(T item, int index)
        {
            //先判断链表是否为空或者插入的位置是否小于1（判断是否可以插入）
            if (IsEmpty()||index<1)
            {
                Console.WriteLine("位置输入错误，请重新输入或者请检查链表是否为空");
            }
            //如果要插入的位置为1，则直接插入到头节点
            if (index==1)
            {
                Node<T> q = new Node<T>(item);
                q.Next = head;
                head = q;
                length++;
            }
            //如果插入的位置大于1或者小于等于链表的长度则代表可以插入
            else if(index>1&&index<=GetLength())
            {
                Node<T> temp = head;
                for (int i = 1; i < index-1; i++)
                {
                    if (temp.Next!=null)
                    {
                        //最后遍历到要插入位置的前一个位置
                        temp = temp.Next;
                    }
                }
                Node<T> q = new Node<T>(item);
                //要插入的位置
                Node<T> tempnext = temp.Next;
                q.Next = tempnext;
                temp.Next = q;
                length++;
            }
            else if (index==GetLength()+1)
            {
                Addend(item);
            }
            else
            {
                Console.WriteLine("插入位置错误，请重新检查");
            }
        }

        /// <summary>
        /// 判断当前链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return head == null;
        }

        /// <summary>
        /// 根据元素得到位置
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            Node<T> temp = head;
            if (!IsEmpty())
            {
                if (head.Data.Equals(value))
                {
                    return 1;
                }
                else
                {
                    for (int i = 1; i < GetLength(); i++)
                    {
                        if (temp.Next != null)
                        {
                            temp = temp.Next;
                        }
                        if (temp.Data.Equals(value))
                        {
                            return i + 1;
                        }
                    }
                    if (!temp.Data.Equals(value))
                    {
                        Console.WriteLine("没有找到这个元素");
                        return -100;
                    }
                } 
            }
                Console.WriteLine("链表为空，无法查找");
                return -100;
        }
    }

双向链表的使用：需要更换节点类，需要继承链表的接口

class DbNode<T>
    {
        private T data;
        private DbNode<T> prev;
        private DbNode<T> next;


        public T Data
        {
            get { return data; }
            set { data = value; }
        }


        public DbNode<T> Prev
        {
            get { return prev; }
            set { prev = value; }
        }


        public DbNode<T> Next
        {
            get { return next; }
            set { next = value; }
        }


        public DbNode(T value, DbNode<T> p)
        {
            data = value;
            next = p;
        }


        public DbNode(DbNode<T> p)
        {
            next = p;
        }
        public DbNode(T value)
        {
            data = value;
            next = null;
        }

        public DbNode()
        {
            data = default(T);
            next = null;
        }
    }

双向链表的实现：

 class DbLinkLis<T> : IListDS<T>
    {
        private DbNode<T> head;
        private DbNode<T> tail;
        private int length;

        public DbNode<T> Head
        {
            get { return head; }
            set { head = value; }
        }

        public DbNode<T> Tail
        {
            get { return tail; }
            set { tail = value; }
        }


        public int Length
        {
            get { return length; }
        }


        public DbLinkLis()
        {
            head = null;
            tail = new DbNode<T>(default(T));
            length = 0;
        }

        public T this[int index]
        {
            get { return GetNode(index).Data; }
        }


        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item"></param>
        public void Addend(T item)
        {
            DbNode<T> q = new DbNode<T>(item);

            if (head == null)
            {
                head = q;
                head.Next = tail;
                tail.Prev = head;
            }
            else
            {
                DbNode<T> temp = tail.Prev;
                temp.Next = q;
                q.Prev = temp;
                q.Next = tail;
                tail.Prev = q;
            }
            length++;

        }

        public void Clear()
        {
            head = null; ;
            tail = new DbNode<T>(default(T));
            length = 0;
        }

        public T Delete(int i)
        {
            T data;
            if (i == 1)
            {
                data = head.Data;
                head = head.Next;
                length--;
            }
            else if (i > GetLength() || i < 1)
            {
                data = default(T);
                Console.WriteLine("超出索引，索引不能为0或超出索引");
            }
            else
            {
                data = GetNode(i).Data;
                DbNode<T> temp = GetNode(i).Next;
                DbNode<T> tempPrev = GetNode(i).Prev;
                tempPrev.Next = temp;
                temp.Prev = tempPrev;
                length--;
            }
            return data;
        }

        /// <summary>
        /// 根据位置查找元素
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public T GetEle(int i)
        {
            return GetNode(i).Data;
        }

        public int GetLength()
        {
            return length;
        }

        /// <summary>
        /// 按照位置插入数据
        /// </summary>
        /// <param name="item">要插入的数据</param>
        /// <param name="i">插入的位置</param>
        public void Insert(T item, int i)
        {
            DbNode<T> q = new DbNode<T>(item);
            if (i == 1)
            {
                DbNode<T> temp = head;
                head = q;
                temp.Prev = head;
                head.Next = temp;
                length++;
            }
            else if (i > GetLength())
            {
                Addend(item);
            }
            else if (i < 1)
            {
                Console.WriteLine("索引不存在，索引必须大于0");
                return;
            }
            else
            {
                DbNode<T> temp = GetNode(i);
                DbNode<T> tempPrev = GetNode(i).Prev;
                temp.Prev = q;
                tempPrev.Next = q;
                q.Prev = tempPrev;
                q.Next = temp;
                length++;
            }
        }

        /// <summary>
        /// 判断链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return length == 0;
        }

        /// <summary>
        /// 通过元素查找节点的位置
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public int Locate(T value)
        {
            for (int i = 1; i <= GetLength(); i++)
            {
                if (value.Equals(GetNode(i).Data))
                {
                    return i;
                }
            }
            Console.WriteLine("数据元素不存在，无法查找");
            return -1;
        }

        /// <summary>
        /// 根据位置查找节点
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        private DbNode<T> GetNode(int i)
        {
            if (i == 1)
            {
                if (head != null)
                {
                    return head;
                }
                else
                {
                    Console.WriteLine("列表是空的");
                    return null;
                }
            }
            else if (i == GetLength())
            {
                return tail.Prev;
            }
            else if (i > GetLength() || i < 1)
            {
                Console.WriteLine("位置错误，无法查找");
                return null;
            }
            else
            {
                if (i <= (GetLength() / 2))
                {
                    DbNode<T> temp = head;
                    for (int j = 1; j < i; j++)
                    {
                        temp = temp.Next;
                    }
                    return temp;
                }
                else
                {
                    DbNode<T> temp = tail;
                    for (int j = GetLength() - i; j >= 0; j--)
                    {
                        temp = temp.Prev;
                    }
                    return temp;
                }
            }
        }
    }