c# 数据结构之单链表

C#单向链表的实现

单向链表的简单说明：链表是一种特殊的数据结构，能够动态的存储一种结构类型数据。在开发复杂的系统时，经常会使用链表存储数据

链表是一种重要的数据结构，该结构由节点组成。每个节点包含两部分数据，第一部分是节点本身的数据，第二部分是指向下一个节点的指针。

对于单向链表，链表中存在两个特殊的节点，分别为“头节点”和“尾节点”。头节点本身没有数据，只存储下一个节点的指针，尾节点只存储数据

//节点类
public class ListNode
{
    public ListNode Previous;
    public ListNode Next;
    public int Value;
    public ListNode(int newValue)
    {
        Value = newValue;
    }
}
/// <summary>
/// 链表类
/// -----------------------------------------------------------------
///   定义结点之后，开始类线性表的操作编程了.在LIST 类中,采用了，
/// Head ,Tail,Current,三个指针，使用Append,MoveFrist,MovePrevious，
/// MoveNext,MoveLast,Delete,InsertAscending,InsertUnAscending
/// ,Clear实现移动，添加，删除,升序插入,降序插入，
///  清空链表操作，GetCurrentValue（） 方法取得当前的值。
public class CList
{
    private ListNode Head;//头指针
    private ListNode Tail;//尾指针
    private ListNode Current;//当前指针
    private int ListCountValue;//链表数据的个数
    public CList()
    {
        //构造函数初始化
        ListCountValue = 0;
        Head = null;
        Tail = null;
    }
    /// <summary>
    /// 尾部添加数据
    /// </summary>
    /// <param name="DataValue"></param>
    public void Append(int DataValue)
    {
        ListNode newNode = new ListNode(DataValue);
        if(IsNull())
        {
            Head = newNode;
            Tail = newNode;
        }
        else
        {
            Tail.Next = newNode;//在尾部添加
            newNode.Previous = Tail;//现在的尾部数据赋值给这个新数据的前一个
            Tail = newNode;//新添加的设置为最后一个
        }
        Current = newNode;
        ListCountValue += 1;
    }
    public void Delect()
    {
        if(!IsNull())
        {
            if(IsBof())
            {
                Head = Current.Next;
                Current = Head;
                ListCountValue -= 1;
                return;
            }
            if(IsEof())
            {
                Tail = Current.Previous;
                Current = Tail;
                ListCountValue -= 1;
                return;
            }
            //若删除中间的数据
            Current.Previous.Next = Current.Next;
            Current = Current.Previous;
            ListCountValue -= 1;
            return;
        }
    }
    /// <summary>
    /// 请空链表
    /// </summary>
    public void Clear()
    {
        MoveFirst();
        while(!IsNull())
        {
            Delect();
        }
    }
    public void Insert(int DataValue)
    {
        ListNode newNote = new ListNode(DataValue);
        if(IsNull())
        {
            Append(DataValue);//为空表的添加
        }
        if(IsBof())
        {
            newNote.Next = Head;
            Head.Previous = newNote;
            Head = newNote;
            Current = Head;
            ListCountValue += 1;
            return;
        }
        //中间插入
        newNote.Next = Current;
        newNote.Previous = Current.Previous;
        Current.Previous.Next = newNote;
        Current.Previous = newNote;
        Current = newNote;
        ListCountValue += 1;
    }
    /// <summary>
    /// 判断是否到达头部
    /// </summary>
    /// <returns></returns>
    public bool IsBof()
    {
        if (Current == Head)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    /// <summary>
    /// 判断是否到达尾部
    /// </summary>
    /// <returns></returns>
    public bool IsEof()
    {
        if(Current == Tail)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    /// <summary>
    /// 判断是否为空链表
    /// </summary>
    /// <returns></returns>
    public bool IsNull()
    {
        if(ListCountValue == 0)
        {
            return true;
        }
        else
        {
            return false;
        }

    }
    /// <summary>
    /// 获取当前值
    /// </summary>
    /// <returns></returns>
    public int GetCurrentValue()
    {
        return Current.Value;
    }
    /// <summary>
    /// 获取链表的数据数量
    /// </summary>
    public int ListCount
    {
        get
        {
            return ListCountValue;        
        }
    }
    /// <summary>
    /// 移动到第一个数据
    /// </summary>
    public void MoveFirst()
    {
        Current = Head;
    }
    /// <summary>
    /// 移动到最后一个数据
    /// </summary>
    public void MoveLast()
    {
        Current = Tail;
    }
    /// <summary>
    /// 移动到第一个数据
    /// </summary>
    public void MovePrevious()
    {
        if(!IsBof())
        {
            Current = Current.Previous;
        }
    }
    public void MoveNext()
    {
        if(!IsEof())
        {
            Current = Current.Next;
        }
    }
    /// <summary>
    /// 进行升序插入
    /// </summary>
    /// <param name="InsertValue"></param>
    public void InsertAscending(int InsertValue)
    {
        if(IsNull())
        {
            Append(InsertValue);
            return;
        }
        MoveFirst();
        if(InsertValue < GetCurrentValue())
        {
            Insert(InsertValue);//满足条件就插入 退出
            return;
        }
        while(true)
        {
            if(InsertValue < GetCurrentValue())
            {
                Insert(InsertValue);
                break;
            }
            if(IsEof())
            {
                Append(InsertValue);
                break;
            }
            MoveNext();
        }
    }
    /// <summary>
    /// 进行降序插入
    /// 参数：InsertValue 插入的数据
    /// </summary>
    public void InsertUnAscending(int InsertValue)
    {
        if (IsNull())//为空链表
        {
            Append(InsertValue);//添加
            return;
        }

        MoveFirst();//移动到头

        if (InsertValue > GetCurrentValue())
        {
            Insert(InsertValue);//满足条件，则插入，退出
            return;
        }

        while (true)
        {
            if (InsertValue > GetCurrentValue())
            {
                Insert(InsertValue);//满族条件，则插入，退出
                break;
            }

            if (IsEof())
            {
                Append(InsertValue);//尾部添加
                break;
            }

            MoveNext();//移动到下一个指针
        }
    }