实战之数据结构篇（线性表，堆栈与队列）

1：定义

    线性表（Linear List）是具有相同特性的数据元素的一个有限序列。该序列中所含元素的个数称作线性表的长度。

    堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权

    栈实际上就是满足先进后出的性质的数学或数据结构。

    （虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因。）

    队列　是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。（队列具有先进先出（FIFO）的特点）

2：实现 

 

  1    定义结点#region 定义结点
  2    public class ListNode
  3    {
  4        public ListNode(int NewValue)
  5        {
  6            Value = NewValue;
  7        }
  8
  9        // 前一个
 10        public ListNode Previous;
 11
 12        // 后一个
 13        public ListNode Next;
 14
 15        // 值
 16        public int Value;
 17    }
 18   #endregion
 19
 20    定义链表类#region 定义链表类
 21    //定义结点之后，开始类线性表的操作编程了.在LIST 类中,采用了，Head ,Tail,  Current，三个指针，使用Append ，MoveFrist,MovePrevious，MoveNext,MoveLast ,Delete,InsertAscending,InsertUnAscending ,Clear 实现移动，添加，删除,升序插入，降序插入，清空链表操作，GetCurrentValue（） 方法取得当前的值。
 22    public class Clist
 23    {
 24        // 头指针
 25        private ListNode Head;
 26        // 尾指针
 27        private ListNode Tail;
 28        // 当前指针
 29        private ListNode Current;
 30        // 链表数据的个数
 31        private int ListCountValue;
 32
 33        public Clist()
 34        {
 35            ListCountValue = 0;
 36            Head = null;
 37            Tail = null;
 38        }
 39
 40        // 尾部添加数据
 41        public void Append(int DataValue)
 42        {
 43            ListNode NewNode = new ListNode(DataValue);
 44            if (IsNull())
 45            //如果头指针为空
 46            {
 47                Head = NewNode;
 48                Tail = NewNode;
 49            }
 50            else
 51            {
 52                Tail.Next = NewNode;
 53                NewNode.Previous = Tail;
 54                Tail = NewNode;
 55            }
 56            Current = NewNode;
 57            //链表数据个数加一
 58            ListCountValue += 1;
 59        }
 60
 61        // 删除当前的数据
 62        public void Delete()
 63        {
 64            //若为空链表
 65            if (!IsNull())
 66            {
 67                //若删除头
 68                if (IsBof())
 69                {
 70                    Head = Current.Next;
 71                    Current = Head;
 72                    ListCountValue -= 1;
 73                    return;
 74                }
 75                //若删除尾
 76                if (IsEof())
 77                {
 78                    Tail = Current.Previous;
 79                    Current = Tail;
 80                    ListCountValue -= 1;
 81                    return;
 82                }
 83                //若删除中间数据
 84                Current.Previous.Next = Current.Next;
 85                Current = Current.Previous;
 86                ListCountValue -= 1;
 87                return;
 88            }
 89
 90        }
 91        // 向后移动一个数据
 92        public void MoveNext()
 93        {
 94            if (!IsEof()) Current = Current.Next;
 95        }
 96        // 向前移动一个数据
 97        public void MovePrevious()
 98        {
 99            if (!IsBof()) Current = Current.Previous;
        }
        // 移动到第一个数据
        public void MoveFrist()
        {
            Current = Head;
        }
        // 移动到最后一个数据
        public void MoveLast()
        {
            Current = Tail;
        }
        // 判断是否为空链表
        public bool IsNull()
        {
            if (ListCountValue == 0)
                return true;
            return false;
        }
        // 判断是否为到达尾部
        public bool IsEof()
        {
            if (Current == Tail)
                return true;
            return false;
        }
        // 判断是否为到达头部
        public bool IsBof()
        {
            if (Current == Head)
                return true;
            return false;
        }
        public int GetCurrentValue()
        {
            return Current.Value;
        }
        // 取得链表的数据个数
        public int ListCount
        {
            get { return ListCountValue; }
        }

        // 清空链表
        public void Clear()
        {
            MoveFrist();
            while (!IsNull())
            {
                //若不为空链表,从尾部删除
                Delete();
            }
        }
        // 在当前位置前插入数据
        public void Insert(int DataValue)
        {
            ListNode NewNode = new ListNode(DataValue);
            if (IsNull())
            {
                //为空表，则添加
                Append(DataValue);
                return;
            }
            if (IsBof())
            {
                //为头部插入
                NewNode.Next = Head;
                Head.Previous = NewNode;
                Head = NewNode;
                Current = Head;
                ListCountValue += 1;
                return;
            }
            //中间插入
            NewNode.Next = Current;
            NewNode.Previous = Current.Previous;
            Current.Previous.Next = NewNode;
            Current.Previous = NewNode;
            Current = NewNode;
            ListCountValue += 1;
        }

        // 进行升序插入
        public void InsertAscending(int InsertValue)
        {
            //参数：InsertValue 插入的数据
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }
            //移动到头
            MoveFrist();
            if ((InsertValue < GetCurrentValue()))
            {
                //满足条件，则插入，退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue < GetCurrentValue())
                {
                    //满族条件，则插入，退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }
        // 进行降序插入
        public void InsertUnAscending(int InsertValue)
        {
            //参数：InsertValue 插入的数据
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }
            //移动到头
            MoveFrist();
            if (InsertValue > GetCurrentValue())
            {
                //满足条件，则插入，退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue > GetCurrentValue())
                {
                    //满族条件，则插入，退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }
    }
    #endregion

    堆栈类#region 堆栈类
    public class CStack
    {
        //调用链表类
        private Clist m_List;

        public CStack()
        {
            //构造函数
            m_List = new Clist();
        }

        // 压入堆栈
        public void Push(int PushValue)
        {
           //参数： int PushValue 压入堆栈的数据
            m_List.Append(PushValue);
        }

        // 弹出堆栈数据,如果为空，则取得 2147483647 为 int 的最大值；
        public int Pop()
        {
            //功能：弹出堆栈数据 
            int PopValue;
            if (!IsNullStack())
            {
                //不为空堆栈
                //移动到顶
                MoveTop();
                //取得弹出的数据
                PopValue = GetCurrentValue();
                //删除
                Delete();
                return PopValue;
            }
            //  空的时候为 int 类型的最大值
            return 2147483647;
        }

        // 判断是否为空的堆栈
        public bool IsNullStack()
        {
            if (m_List.IsNull())
                return true;
            return false;
        }

        // 堆栈的个数
        public int StackListCount
        {
            get{return m_List.ListCount;}
        }
        
        // 移动到堆栈的底部
        public void MoveBottom()
        {
            m_List.MoveFrist();
        }
        
        // 移动到堆栈的Top
        public void MoveTop()
        {
            m_List.MoveLast();
        }

        // 向上移动
        public void MoveUp()
        {
            m_List.MoveNext();
        }
        
        // 向下移动
        public void MoveDown()
        {
            m_List.MovePrevious();
        }
        
        // 取得当前的值
        public int GetCurrentValue()
        {
            return m_List.GetCurrentValue();
        }
        
        // 删除取得当前的结点
        public void Delete()
        {
            m_List.Delete();
        }
        
        // 清空堆栈
        public void Clear()
        {
            m_List.Clear();
        }
    }
    #endregion

    队列类#region 队列类
    public class CQueue
    {
        private Clist m_List;
        public CQueue()
        {
            //构造函数
            //这里使用到前面编写的List 
            m_List = new Clist();
        }

        // 入队
        public void EnQueue(int DataValue)
        {
            //功能：加入队列，这里使用List 类的Append 方法：
            //尾部添加数据，数据个数加1
            m_List.Append(DataValue);
        }

        // 出队
        public int DeQueue()
        {
            //功  能：出队
            //返回值： 2147483647 表示为空队列无返回
            int QueValue;
            if (!IsNull())
            {
                //不为空的队列
                //移动到队列的头
                m_List.MoveFrist();
                //取得当前的值
                QueValue = m_List.GetCurrentValue();
                //删除出队的数据
                m_List.Delete();
                return QueValue;
            }
            return 2147483647;
        }

        // 判断队列是否为空
        public bool IsNull()
        {
            //功能：判断是否为空的队列
            return m_List.IsNull();
        }

        // 清空队列
        public void Clear()
        {
            //清空链表
            m_List.Clear();
        }

        // 取得队列的数据个数
        public int QueueCount
        {
            get
            {
                //取得队列的个数
                return m_List.ListCount;
            }
        }
    }
    #endregion