C#下Queue的实现及其解决实例(队列解决排序问题----不需要逻辑运算符来进行比较)

自己实现了队列的功能,并通过队列进行排序的方法。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;


public class WQueue<T>
{
    //队列中储存数据的个数
    private int m_Count;
    //添加的指针位置
    private int m_QueueTailPointer;
    //队头位置指针
    private int m_QueueHeadPointer;
    //队列容量
    private int m_Capacity;
    //储存数据数组
    private T[] StoreArray;

    public int Count { get { return m_Count; } private set { m_Count = value; } }

    public int Capacity { get { return m_Capacity; } private set { m_Capacity = value; } }
    //Queue
    public WQueue(int Capacity=4)
    {
        m_QueueTailPointer = 0;
        m_QueueHeadPointer = 0;
        m_Count = 0;
        m_Capacity = Capacity;
        StoreArray = new T[Capacity];
    }
    //返回队头数据,删除
    public T Dequeque()
    {
        if(m_Count==0)
        {
            Console.WriteLine("当前队列没有储存数据");
            return default(T);
        }
        else
        {
            //临时数据
            T tempdata;
            //得到队头数据
            tempdata = StoreArray[m_QueueHeadPointer];
            //设置当前值为默认值
            StoreArray[m_QueueHeadPointer] = default(T);
            //当队头指向尾最后一个数据切数据数量不为零时，队头指向第一个
            if (m_QueueHeadPointer == m_Capacity - 1&&m_Count!=0)
            {
                m_QueueHeadPointer = 0;
            }
            else
            {
                m_QueueHeadPointer++;
            }
            //由于出队数量减少一个
            m_Count--;
            return tempdata;
        }
    }
    //返回队首的值，不删除
    public T Peek()
    {
        if (m_Count == 0)
        {
            Console.WriteLine("当前队列没有储存数据");
            return default(T);
        }
        else
        {
            T tempdata = StoreArray[m_QueueHeadPointer];
            return tempdata;
        }
    }
    //入队
    public void Enqueque(T data)
    {
        //当储存的数组数量等于容量的时候需要扩容，每次扩容为原来的两倍大小
        if(m_Count==m_Capacity)
        {
            m_Capacity *= 2;

            T[] tempArray = new T[m_Capacity];

            //当队头指针小于等于队尾指针序号的时候直接拷贝数组
            if(m_QueueHeadPointer<m_QueueTailPointer)
            {
                Array.Copy(StoreArray, 0, tempArray, 0, m_Count);
            }
            //当队头指针大于等于队尾指针序号的时候表示数组进行过出队后再添加数据入队
            //所以拷贝数组的时候需要重置队列的位置
            else
            {
                //拷贝队首至数组末尾的数据至新数组里
                Array.Copy(StoreArray, m_QueueHeadPointer, tempArray, 0, m_Capacity/2 - m_QueueHeadPointer);
                //拷贝从数组0位置到队尾
                Array.Copy(StoreArray, 0, tempArray, m_Capacity/2 - m_QueueHeadPointer,m_QueueTailPointer+1);
                m_QueueHeadPointer = 0;
                m_QueueTailPointer = m_Count - 1;
                //Array.Copy(StoreArray,,tempArray,0,)
            }
            StoreArray = tempArray;
        }
        else
        {
            //当数量等于容量-队首指针的时候表示数组后面不能再储存数据
            //队尾指针要指向数组首地址
            if(m_Count == m_Capacity-m_QueueHeadPointer)
            {
                m_QueueTailPointer = 0;
            }
        }
        StoreArray[m_QueueTailPointer++] = data;
        m_Count++;
    }
}

以下是通过队列来进行排序的功能

class Program
    {
        //储存数据类
        public class Account
        {
            public string name;

            public int index;

            public Account(string name, int index)
            {
                this.name = name;
                this.index = index;
            }

            public override string ToString()
            {
                return string.Format("用户名字是{0},用户序号是{1}", name, index);
            }
        }

        static void Main(string[] args)
        {
            WQueue<int>[] test = new WQueue<int>[10];

            for (int i = 0; i < test.Length; i++)
            {
                test[i] = new WQueue<int>();
            }
            int[] array = new int[] { 15, 12, 91, 82, 55, 72 };
            QueueSort(array, test, Digit.units);
            GetArray(test, array);
            QueueSort(array, test, Digit.ten);
            GetArray(test, array);
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }
            //Account account0 = new Account("OneSitDown0", 1);
            //Account account1 = new Account("OneSitDown1", 2);
            //Account account2 = new Account("OneSitDown2", 3);
            //Account account3 = new Account("OneSitDown3", 4);
            //Account account4 = new Account("OneSitDown4", 5);

            //test.Enqueque(account0);
            //test.Enqueque(account1);
            //Console.WriteLine(test.Capacity);
            //Console.WriteLine(test.Dequeque());
            //test.Enqueque(account2);
            //test.Enqueque(account3);
            //test.Enqueque(account4);
            //test.Enqueque(account0);
            //Console.WriteLine(test.Dequeque());
            //Console.WriteLine(test.Dequeque());
            //Console.WriteLine(test.Dequeque());
            //Console.WriteLine(test.Dequeque());
            Console.ReadKey();
        }


        public enum Digit
        {
            units = 1,
            ten = 10
        }

        public static void QueueSort(int[] array, WQueue<int>[] QueueArray, Digit digit)
        {
            int num;

            for (int i = 0; i < array.Length; i++)
            {
                if (digit == Digit.units)
                {
                    num = array[i] % 10;
                }
                else
                {
                    num = array[i] / 10;
                }
                QueueArray[num].Enqueque(array[i]);
            }
        }
        public static void GetArray(WQueue<int>[] QueueArray, int[] n)
        {
            int index = 0;
            for (int i = 0; i < QueueArray.Length; i++)
            {
                while (QueueArray[i].Count > 0)
                {
                    n[index++] = QueueArray[i].Dequeque();
                }
            }
        }
    }