数据结构（尚硅谷）Java&C# 数组模拟队列

队列

1. 队列是一个有序列表，可以用数组或是链表来实现。
2. 遵循先入先出原则，即：先存入队列的数据，要先取出，后存入的要后取出。

视频里面老师讲的很清楚，下面是跟着视频敲的Java代码，后面是自己修改为C#语言的代码，刚学的C#不是很熟练，供参考。

Java:

import java.util.Scanner;

public class ArrayQueueDemo {
    public static void main(String[] args) {
        ArrayQueue queue = new ArrayQueue(3);
        char key = ' ';//接收用户输入
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单
        while(loop){
            System.out.println("s(show)：显示队列");
            System.out.println("e(exit)：退出程序");
            System.out.println("a(add)：添加数据");
            System.out.println("g(get)：从队列取出数据");
            System.out.println("h(head)：查看队列头的数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch(key){
                case 's':
                    queue.showQueue();
                    break;
                case 'a':
                    System.out.println("输出一个数");
                    int value = scanner.nextInt();
                    queue.addQueue(value);
                    break;
                case 'g':
                    try {
                        int res = queue.getQueue();
                        System.out.printf("取出的数据是：%d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h'://查看队列头的数据
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是：%d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e'://退出
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }

    //使用数组模拟队列-编写一个ArrayQueue类
    static class ArrayQueue{
        private int maxSize;    //数组的最大容量
        private int front;      //队列头
        private int rear;       //队列尾
        private int[] arr;      //数组的最大容量

        //创建队列的构造器
        public ArrayQueue(int arrMaxSize) {
            maxSize = arrMaxSize;
            arr = new int[maxSize];
            front = -1;  //指向队列头部，指向队列头的前一个位置
            rear = -1;   //指向队列尾部的数据
        }

        //判断队列是否满了
        public boolean isFull() {
            return rear == maxSize - 1;
        }

        //判断队列是否为空
        public boolean isEmpty() {
            return rear == front;
        }

        //添加数据到队列
        public void addQueue(int n) {
            if(isFull()){
                System.out.println("队列满了，不能加入了");
                return;
            }
            rear++;//让rear后移
            arr[rear] = n;  
        }

        //获取队列的数据，出队列
        public int getQueue() {
            //判断队列是否空
            if(isEmpty()){
                //抛出异常
                throw new RuntimeException("队列空，不能取数据");
            }
            front++;//后移
            return arr[front];
        }

        //显示队列的所有数据
        public void showQueue() {
            //遍历
            if(isEmpty()){
                System.out.println("队列为空");
                return;
            }else{
                for(int i = 0; i < arr.length;i++){
                    System.out.printf("arr[%d]=%d\n",i,arr[i]);
                }
            }
        }

        //显示队列的头数据
        public int headQueue() {
            if(isEmpty()){
                //抛出异常
                throw new RuntimeException("队列空，不能取数据");
            }
            return arr[front + 1];
        }
    }
}

C#:

namespace Csharp9._0 {
    public class Class4 {
        static void Main(string[] args) {
            ArrayQueue<int> queue = new ArrayQueue<int>(3);
            char key;//接收用户输入
            bool loop = true;
            //输出一个菜单
            while (loop) {
                Console.WriteLine("s(show)：显示队列");
                Console.WriteLine("e(exit)：退出程序");
                Console.WriteLine("a(add)：添加数据");
                Console.WriteLine("g(get)：从队列取出数据");
                Console.WriteLine("h(head)：查看队列头的数据");
                try {
                    string a = Console.ReadLine();
                    key = Convert.ToChar(a);
                    switch (key) {
                        case 's':
                            queue.ShowQueue();
                            break;
                        case 'a':
                            Console.WriteLine("输出一个数");
                            string value = Console.ReadLine();
                            var _value = Convert.ToInt32(value);
                            queue.AddQueue(_value);
                            break;
                        case 'g':
                            try {
                                int res = queue.GetQueue();
                                Console.WriteLine("取出的数据是：{0}\n", res);
                            }
                            catch (Exception e) {
                                Console.WriteLine(e.Message);
                            }
                            break;
                        case 'h'://查看队列头的数据
                            try {
                                int res = queue.HeadQueue();
                                Console.WriteLine("队列头的数据是：{0}\n", res);
                            }
                            catch (Exception e) {
                                Console.WriteLine(e.Message);
                            }
                            break;
                        case 'e'://退出
                            loop = false;
                            break;
                        default:
                            break;
                    }
                }
                catch (Exception e) { Console.WriteLine(e.Message); }

                
            }
            Console.WriteLine("程序退出");
        }

        //使用数组模拟队列-编写一个ArrayQueue类
        class ArrayQueue<T> {
            private int maxSize;    //数组的最大容量
            private int front;      //队列头
            private int rear;       //队列尾
            private T[] queues;     //数组的最大容量

            //创建队列的构造器
            public ArrayQueue(int _maxSize) {
                maxSize = _maxSize;
                queues = new T[maxSize];
                front = -1;  //指向队列头部，指向队列头的前一个位置
                rear = -1;   //指向队列尾部的数据
            }

            //判断队列是否满了
            public bool IsFull() {
                return rear == maxSize - 1;
            }

            //判断队列是否为空
            public bool IsEmpty() {
                return rear == front;
            }

            //添加数据到队列
            public void AddQueue(T n) {
                if (IsFull()) {
                    Console.WriteLine("队列满了，不能加入了");
                    return;
                }
                rear++;//让rear后移
                queues[rear] = n;
            }

            //获取队列的数据，出队列
            public T GetQueue() {
                //判断队列是否空
                if (IsEmpty()) {
                    //抛出异常
                    throw new Exception("队列空，不能取数据");
                }
                front++;//后移
                return queues[front];
            }

            //显示队列的所有数据
            public void ShowQueue() {
                //遍历
                if (IsEmpty()) {
                    Console.WriteLine("队列为空");
                    return;
                }
                else {
                    for (int i = 0; i < queues.Length; i++) {
                        Console.WriteLine("arr[{0}]={1}\n", i, queues[i]);
                    }
                }
            }

            //显示队列的头数据
            public T HeadQueue() {
                if (IsEmpty()) {
                    //抛出异常
                    throw new Exception("队列空，不能取数据");
                }
                return queues[front + 1];
            }
        }
    }
}