数组模拟队列

有序列表，先入先出

单队列

        队列本身是个有序列表，若用数组的结构来储存队列的数据，则队列数组的声明如下图，其他maxSize是该队列的最大容量
         因为队列的输出、输入分别从前后端来处理，因此需要两个变量front及rear分别记录队列前后端的下标，front会随着数据输出而改变，rear随着数据的输入而改变

public class QueueClass
{
    int maxSize = 0; // 队列的最大容量
    int front = -1; //是队列最前（不含）队列的前一个位置
    int rear = -1; //是队列最后（含）
    int[] arr;

    public QueueClass(int len)
    {
        maxSize = len;
        arr = new int[len];
    }


     public bool isFull()
     {
         return rear == maxSize-1;
     }

     public bool isEmpty()
     {
         return rear == front;
     }

     public void addQueue(int num)
     {
        if (isFull())
        {
             Console.WriteLine("队列已满");
        }

        rear ++;
        arr[rear]= num;
        Console.WriteLine("已添加"+num);
     }

     public int getQueue()
     {
        if (isEmpty())
        {
            throw new Exception("队列中内没有有数据");
        }
        
        front++;
        Console.WriteLine("取出数据："+arr[front]);
        return arr[front];
     }

     public void showQueue()
     {
        if (isEmpty())
        {
            Console.WriteLine("队列中内没有有数据");
        }
        Console.Write("队列数据：");
        for (int i = (front+1); i <= rear; i++)
        {
            Console.Write(arr[i]+"\t");
        }
        Console.WriteLine();
     }

     public int headQueue()
     {
        if (isEmpty())
        {
            throw new Exception("队列中内没有有数据");
        }
        Console.WriteLine("头数据："+arr[front+1]);
        return arr[front+1];
     }

}

环形队列

        front 指向队列的第一个元素
        rear 指向队列的最后一个元素的后一个位置
        队列满： （rear+1）% maxSize=front   :  rear和front都为下标，第一次满队列rear+1%maxSize 才为0，将rear+1作为一个虚拟位置，front增加，rear+1也增加
        队列空： rear = front
        队列的有效个数： （rear+maxSize-front）% maxSizes

public class QueueClass_Circular
{

    int maxSize = 0; // 队列的最大容量
    int front = 0; //指向队列的第一个元素
    int rear = 0; //指向队列的最后一个元素的后一个位置
    int[] arr;

    public QueueClass_Circular(int len)
    {
        maxSize = len;
        arr = new int[len];
    }

    //队列满时
    public bool isFull()
     {
         //rear和front都为下标，第一次满队列rear+1%maxSize 才为0，将rear+1作为一个虚拟位置，front增加，rear+1也增加
         return (rear+1)% maxSize == front;
     }

     public bool isEmpty()
     {
         return rear == front;
     }


     public void addQueue(int num)
     {
        if (isFull())
        {
            throw new Exception("队列已满！");
        }

        arr[rear]= num;

        rear = (rear +1)%maxSize;  //rear一直增加会进行数组越界

        Console.WriteLine(string.Format("{0} 已添加",num));
     }

     public int getQueue()
     {
        if (isEmpty())
        {
            throw new Exception("队列中内没有有数据");
        }

        int value = arr[front];
        front = (front +1)%maxSize;
        Console.WriteLine("取出数据："+value.ToString());
        return value;
     }

     public void showQueue()
     {
        if (isEmpty())
        {
            Console.WriteLine("队列中内没有有数据");
        }
        Console.Write("显示队列数据：");
        for (int i = front; i < front +GetNumber(); i++)
        {
            int index = i% maxSize;
            Console.Write(string.Format(arr[index].ToString()+"\t"));
        }
        Console.WriteLine();
     }

     public int headQueue()
     {
        if (isEmpty())
        {
            throw new Exception("队列中内没有有数据");
        }
        Console.WriteLine("头数据"+arr[front].ToString());
        return arr[front];
     }

    //有效个数
    int GetNumber()
    {
        //有效个数
        return (rear+maxSize-front) % maxSize;
    }
}