Вычислить количество элементов массива, лежащих в диапазоне от А до В

    class Program
    {
        static void Main(string[] args)
        {
            int N;
            Console.Write("Введите N: ");
            N = Convert.ToInt32(Console.ReadLine());
 
            int A;
            Console.Write("Введите A: ");
            A = Convert.ToInt32(Console.ReadLine());
            int B;
            Console.Write("Введите B: ");
            B = Convert.ToInt32(Console.ReadLine());
            int[] myIntArray = new int[N];
            for (int i = 0; i < N; i++)
            {
                Console.Write("Введите A[" + i + "]: ");
                myIntArray[i] = int.Parse(Console.ReadLine());
            };
            int Q = 0;
            for (int i = 0; i < N; i++)
            {
                if ((myIntArray[i] < B) && (myIntArray[i] > A))
                    Q++;
            };
            Console.Write("Количество чисел в диапозоне [" + A + ".." + B + "]= [" + Q + "]:");
            int max = myIntArray[0];
            int n_max = 0;
            for (int i = 0; i < N; i++)
            {
                if (myIntArray[i] > max)
                {
                    max = myIntArray[i];
                    n_max = i;
                };
            }
            int sum = 0;
            for (int i = n_max + 1; i < N; i++)
                sum = sum + myIntArray[i];
            Console.Write("Сумма элементов после массива [" + sum + "]: ");
            Console.Read();
 
            for (int i = 1; i < N; i++)
            {
                int p;
                if (myIntArray[i] < myIntArray[i - 1])
                {
                    p = myIntArray[i - 1];
                    myIntArray[i - 1] = myIntArray[i];
                    myIntArray[i] = p;
                    while

// фукнция сортировки
        void QuickSort(double* array, int a, int b)
        {
            int A = a;
            int B = b;
            double mid;
 
            if (b > a)
            {
 
                // Находим разделительный элемент в середине массива
                mid = array[(a + b) / 2];
 
                // Обходим массив
                while (A <= B)
                {
                    /* Находим элемент, который больше или равен
                    * разделительному элементу от левого индекса.
                    */
                    while ((A < b) && (array[A] < mid)) ++A;
 
                    /* Находим элемент, который меньше или равен
                     * разделительному элементу от правого индекса.
                     */
                    while ((B > a) && (array[B] > mid)) --B;
 
                    // Если индексы не пересекаются, меняем
                    if (A <= B)
                    {
                        double T;
                        T = array[A];
                        array[A] = array[B];
                        array[B] = T;
 
                        ++A;
                        --B;
                    }
                }
 
                /* Если правый индекс не достиг левой границы массива,
                 * нужно повторить сортировку левой части.
                 */
                if (a < B) QuickSort(array, a, B);
 
                /* Если левый индекс не достиг правой границы массива,
                 * нужно повторить сортировку правой части.
                 */
                if (A < b) QuickSort(array, A, b);
 
            }
        }
 
        void QuickSort(double* array, int n)
        {
            QuickSort(array, 0, n - 1);
        }