线性群集之栈和队列

一：栈

栈这个数据结构在计算机中应用十分广泛。是只能在某一端插入和删除的特殊线性表。它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。 栈也称为先进后出表。

栈在程序的运行中有着举足轻重的作用。最重要的是栈保存了一个函数调用时所需要的维护信息，这常常称之为堆栈帧或者活动记录。堆栈帧一般包含如下几方面的信息：

1. 函数的返回地址和参数

2. 临时变量：包括函数的非静态局部变量以及编译器自动生成的其他临时变量。

栈的链表实现：

 public class MyStack

    {

        private object _obj = new object();

        private Node top = null;

        private int count=0;

        public void Push(Node node)

        {

            lock (_obj)

            {

                node.next = null;

                if (top == null)

                {

                    top = node;

                }

                else

                {

                    node.next = top;

                    top = node;

                }

                count++;

            }

        }

        public Node Pop()

        {

            lock(_obj)

            {

                if (top != null)

                {

                    Node temp = top;

                    top = top.next;

                    count--;

                    return temp;

                }

                else

                {

                    return null;

                }

            }

        }

        public int Count

        {

            get

            {

                lock (_obj)

                {

                    return count;

                }

            }

        }

    }

栈的数组实现：

public class MyStack
    {
        private object _obj = new object();
        private object[] _objArray = null;
        private int top = 0;
        private int MaxSize = 0;

        public MyStack(int MaxSize)
        {
            this.MaxSize = MaxSize;
            _objArray = new object[MaxSize];
        }
        public bool Push(object obj)
        {
            lock (_obj)
            {
                if (top < MaxSize)
                {
                    _objArray[top] = obj;
                    top++;
                    return true;
                }
                else
                {
                    return false;
                }

            }
        }

        public object Pop()
        {
            lock (_obj)
            {
                if (top != 0)
                {
                    top--;
                    return _objArray[top];
                }
                else
                {
                    return null;
                }
            }
        }
    }

二：队列

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

在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将最后被删除的元素，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。

队列空的条件：front=rear

队列满的条件： rear = MAXSIZE

队列在实现的时候也比较简单，先来看链表实现队列的方式：

class MyQueue
    {
        private Node head = null;
        private Node tail = null;
        private int count = 0;
        public void Enqueue(Node node)
        {
            if (tail == null)
            {
                head = tail = node;
            }
            else
            {
                tail.next = node;
                tail = node;
            }
            count++;
        }
        public Node Dequeue()
        {
            if (head !=null)
            {
                return null;
            }
            Node temp = head;
            if (head.next ==null)
            {
                head = tail = null;
            }
            else
            {
                head = head.next;
            }
            count--;
            return temp;
        }

        public int Count
        {
            get { return count; }
        }
    }

下面来看使用数组来实现队列，数组实现队列的时候有一点点小的技巧，如果队列尾部已经没有空间，但是首部还有空间，我们可以使用队列的首部腾出的空间来存储数据，这样可以提高空间的利用率。

class MyQueue
    {
        private object[] objarray = null;
        int MaxSize = 0;
        int head = 0;
        int tail = 0;
        int size = 0;
        public MyQueue(int Maxsize)
        {
            MaxSize = Maxsize;
            objarray = new object[Maxsize];
        }
        public bool Enqueue(Object obj)
        {
           if (size == MaxSize)
           {
               return false;
           }
           objarray[tail] = obj;
           //这里保证了空间可以被复用
           //一旦tail>MaxSize就可以去利用前面释放的空间
           tail = (tail + 1) % MaxSize;
           size++;
           return true;
        }
        public object Dequeue()
        {
            if (size == 0)
            {
                return null;
            }
            object removed = objarray[head];
            objarray[head] = null;
            head = (head + 1) % MaxSize;
            size--;
            return removed;
        }
        public int Length
        {
            get { return this.size; }
        }
    }