双向链表

基本上，我们可以认为双向链表是单链表的一个改进。这个改进一个有益的地方就是，双链表不必像单链表一样，为了查找一个元素，沿着链表的特定一个方向，从头遍历到尾。通过双链表，我们可以沿着正反两个方向对链表内的元素进行查找。

双链表的结点与单链表（循环链表）的稍稍有点不同，主要的不同就在与，双链表的节点多出了一个连接前一个节点的字段（详见灰色部分）。如下所示

class DulNode<T>

{

    private T data;

    /// <summary>

    /// 数据域

    /// </summary>

    public T Data

    {

        get {return data;}

        set { data = value;}

    }

 

 

    private DulNode<T> next;

    /// <summary>

    /// 引用域

    /// </summary>

    public DulNode<T> Next

    {

        get {return next;}

        set { next = value;}

    }

    private DulNode<T> prior;

 

    public DulNode<T> Prior

    {

        get {return prior;}

        set { prior = value;}

    }

   

    //头结点构造函数

    public DulNode(DulNode<T> next)

        :this(default(T),null, next)

    {

    }

    //头结点构造函数

    public DulNode(T data)

        :this(data,null,null)

    {

    }

    //普通结点构造函数

    public DulNode(T data,DulNode<T> prior, DulNode<T> next)

    {

        this.Data = data;

        this.Next = next;

        this.Prior = prior;

    }

    /// <summary>

    /// 空构造函数

    /// </summary>

    public DulNode()

        :this(default(T),null,null)

    {

    }

    //尾结点构造函数

    public DulNode(T data,DulNode<T> prior)

        :this(data, prior,null)

    {

 

    }

 

}

 

我们初始化一个双向链表，以便让大家更加直观的了解到双向链表中头结点和尾节点的不同。这个链表有四个节点，我们分别用0,1,2,3填充这个链表。

头节点如下所示：（其中next代表连接后一个节点的后导节点，prior代表连接前一个节点的前导节点）

尾节点如下所示：

普通的节点如下所示：

 

双向链表具体的实现如下所示

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace DataStructure

{

    class DulList<T>: IListDS<T>

    {

        class DulNode<T>

        {

            private T data;

            /// <summary>

            /// 数据域

            /// </summary>

            public T Data

            {

                get {return data;}

                set { data = value;}

            }

 

 

            private DulNode<T> next;

            /// <summary>

            /// 引用域

            /// </summary>

            public DulNode<T> Next

            {

                get {return next;}

                set { next = value;}

            }

            private DulNode<T> prior;

 

            public DulNode<T> Prior

            {

                get {return prior;}

                set { prior = value;}

            }

 

            //头结点构造函数

            public DulNode(DulNode<T> next)

                :this(default(T),null, next)

            {

            }

            //头结点构造函数

            public DulNode(T data)

                :this(data,null,null)

            {

            }

            //普通结点构造函数

            public DulNode(T data, DulNode<T> prior, DulNode<T> next)

            {

                this.Data = data;

                this.Next = next;

                this.Prior = prior;

            }

            /// <summary>

            /// 空构造函数

            /// </summary>

            public DulNode()

                :this(default(T),null,null)

            {

            }

            //尾结点构造函数

            public DulNode(T data, DulNode<T> prior)

                :this(data, prior,null)

            {

 

            }

 

        }

 

        private DulNode<T> Head;

 

        public DulList(T[] t)

        {

            this.Head =new DulNode<T>(t[0]);

            DulNode<T> Current;

            Current = Head;

            for(int i =1; i < t.Length; i++)

            {

                DulNode<T> newNode =new DulNode<T>(t[i]);

                //设置前一个连接点

                newNode.Prior = Current;

                //当前节点的next设置为新的节点

                Current.Next = newNode;

                //将当前节点的引用域指向新的节点

                Current = newNode;

            }

        }

 

        public DulList()

        {

        }

 

        publicint Lenth

        {

            get {returnthis.GetLength();}

        }

 

        public States Append(T item)

        {

            //(1)头结点没有

            if(Head ==null)

            {

                Head =new DulNode<T>(item);

                return States.Success;

            }

            //(2)正常的插入情况

            DulNode<T> Last;

            Last = Head;

            //遍历到最后一个结点，在最后一个结点附加上

            while(null!= Last.Next)

            {

                Last = Last.Next;

            }

            DulNode<T> newNode =new DulNode<T>(item);

            Last.Next = newNode;

            newNode.Prior = Last;

            return States.Success;

        }

 

        publicvoid Clear()

        {

            Head =null;

        }

 

        public T Delete(int index,out States states)

        {

            bool isIndexTrue = index <0|| index >=this.GetLength();

            if(IsEmpty()==true|| isIndexTrue)

            {

                states = States.Fail;

                returndefault(T);

            }

            //找到指定的结点

            DulNode<T> Current = Head;

            DulNode<T> Previous = Head;

            int Count =0;

            while(Count != index && Current.Next !=null)

            {

                Previous = Current;

                Current = Current.Next;

                Count++;

            }

            T ValueToDel = Current.Data;

            //是否是头结点

            if(Count ==0)

            {

                Head = Current.Next;

                Current.Next.Prior =null;

            }

            //是否是普通的结点

            if(Count !=0&& Current.Next !=null)

            {

                Previous.Next = Current.Next;

                Current.Next.Prior = Previous;

            }

            //是否是最后一个结点

            if(Count !=0&& Current.Next ==null)

            {

                Previous.Next =null;

            }

 

            //删除结点

            states = States.Success;

            return ValueToDel;

        }

 

        public T GetElem(int i)

        {

            if(i <0|| i >=this.GetLength())

            {

                returndefault(T);

            }

            if(IsEmpty()==true)

            {

                returndefault(T);

            }

 

            DulNode<T> Last = Head;

            int Count =0;

            while(Count != i && Last.Next !=null)

            {

                Last = Last.Next;

                Count++;

            }

            return Last.Data;

        }

 

        publicint GetLength()

        {

            if(Head ==null)

            {

                return0;

            }

            DulNode<T> Last;

            Last = Head;

            int Count =0;

            while(Last.Next !=null)

            {

                Last = Last.Next;

                Count++;

            }

            return++Count;

        }

 

        public States Insert(T item,int index)

        {

            bool isIndexTrue = index <0|| index >this.GetLength();

            if(isIndexTrue)

            {

                return States.Fail;

 

            }

            //如果链表为空

            if(IsEmpty()==true)

            {

                Head.Data = item;

            }

            //如果是第一个结点

            if(index ==0)

            {

                DulNode<T> NewNode =new DulNode<T>(item);

                NewNode.Next = Head;

                Head.Prior = NewNode;

                Head = NewNode;

                return States.Success;

            }

            //如果是普通的结点

            DulNode<T> Previous = Head;//当前节点的前一个

            int Count =0;

            while(Count != index -1&& Previous.Next !=null)//因为要取到插入位置的前一个节点所以用Count != index-1的判断

            {

                Previous = Previous.Next;

                Count++;

            }

            //如果是最后一个结点

            if(this.GetLength()== index)

            {

                DulNode<T> NewNode =new DulNode<T>(item);

                Previous.Next = NewNode;

                NewNode.Prior = Previous;

                return States.Success;

            }

            if(Count == index -1)

            {

                DulNode<T> NewNode =new DulNode<T>(item);

                DulNode<T> Current = Previous.Next;

                NewNode.Next = Current;

                Current.Prior = NewNode;

                NewNode.Prior = Previous;

                Previous.Next = NewNode;

            }

 

            return States.Success;

        }

 

        publicbool IsEmpty()

        {

            return Head ==null?true:false;

        }

 

        publicint Locate(T value,out States states)

        {

            if(IsEmpty()==true)

            {

                states = States.Fail;

                return0;

            }

 

            DulNode<T> Last = Head;

            int Index =0;

            while(Last.Next !=null&&(!value.Equals(Last.Data)))

            {

                Last = Last.Next;

                Index++;

            }

            states = States.Success;

            return Index;

        }

    }

}