Example #1
0
        public int[][] Sort3Tasks(int quantityTasks, int quantityProcessors, ref int[][] ArrayOfTasks)
        {
            Sort1Tasks(quantityTasks, quantityProcessors, ref ArrayOfTasks);
            int[]     ArrayOfinfinity = new int[quantityTasks]; //массив недостижимостей
            int[]     someArray       = new int[quantityTasks]; //хранит нагрузку задания
            int[]     someArrayKey    = new int[quantityTasks];
            IComparer revComparer     = new ReverseComparer();

            for (int j = 0; j < quantityProcessors; j++) // инициализация
            {
                ArrayOfinfinity[j] = 0;
            }

            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    if (ArrayOfTasks[i][j] >= 0)
                    {
                        someArray[i]    = ArrayOfTasks[i][j]; // храним значение однородной загрузки
                        someArrayKey[i] = i;
                    }
                    else
                    {
                        ArrayOfinfinity[i]++; //считаем кол-во бесконечностей
                    }
                }
            }
            int temp  = someArray[0];
            int tempi = 0;
            int len   = 0;

            for (int i = 1; i < quantityTasks; i++)
            {
                if (temp == someArray[i])
                {
                    len++;
                }
                else
                {
                    Array.Sort(ArrayOfinfinity, ArrayOfTasks, tempi, len + 1, revComparer);
                    temp  = someArray[i];
                    tempi = i;
                    len   = 0;
                }
            }
            Array.Sort(ArrayOfinfinity, ArrayOfTasks, tempi, len + 1, revComparer);

            return(ArrayOfTasks);
        }
Example #2
0
        public int[][] Sort2Tasks(int quantityTasks, int quantityProcessors, ref int[][] ArrayOfTasks) //сортировка по убыванию количества бесконечностей
        {
            int[]     ArrayOfinfinity = new int[quantityTasks];                                        //массив недостижимостей
            int[]     someArray       = new int[quantityTasks];                                        //хранит нагрузку задания
            int[]     someArrayKey    = new int[quantityTasks];
            IComparer revComparer     = new ReverseComparer();

            int[][] ArrayOfTasksCopy = new int[quantityTasks][]; //копия массива заданий
            for (int i = 0; i < quantityTasks; i++)              //создание массива
            {
                ArrayOfTasksCopy[i] = new int[quantityProcessors];
            }
            for (int j = 0; j < quantityProcessors; j++) // инициализация
            {
                ArrayOfinfinity[j] = 0;
            }
            for (int i = 0; i < quantityTasks; i++) //копирование
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    ArrayOfTasksCopy[i][j] = ArrayOfTasks[i][j];
                }
            }
            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    if (ArrayOfTasks[i][j] >= 0)
                    {
                        someArray[i]    = ArrayOfTasks[i][j]; // храним значение однородной загрузки
                        someArrayKey[i] = i;
                    }
                    else
                    {
                        ArrayOfinfinity[i]++; //считаем кол-во бесконечностей
                    }
                }
            }
            Array.Sort(ArrayOfinfinity, someArrayKey, revComparer);
            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    ArrayOfTasks[i][j] = ArrayOfTasksCopy[someArrayKey[i]][j];
                }
            }
            return(ArrayOfTasks);
        }
Example #3
0
        public int[][] Sort1Tasks(int quantityTasks, int quantityProcessors, ref int[][] ArrayOfTasks) //сортировка по убыванию
        {
            int[]   someArray        = new int[quantityTasks];                                         //хранит нагрузку задания
            int[]   someArrayKey     = new int[quantityTasks];
            int[][] ArrayOfTasksCopy = new int[quantityTasks][];
            for (int i = 0; i < quantityTasks; i++)
            {
                ArrayOfTasksCopy[i] = new int[quantityProcessors];
            }
            IComparer revComparer = new ReverseComparer();

            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    ArrayOfTasksCopy[i][j] = ArrayOfTasks[i][j];
                }
            }
            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    if (ArrayOfTasks[i][j] >= 0)
                    {
                        someArray[i]    = ArrayOfTasks[i][j];
                        someArrayKey[i] = i;
                        break;
                    }
                }
            }
            Array.Sort(someArray, someArrayKey, revComparer);
            for (int i = 0; i < quantityTasks; i++)
            {
                for (int j = 0; j < quantityProcessors; j++)
                {
                    ArrayOfTasks[i][j] = ArrayOfTasksCopy[someArrayKey[i]][j];
                }
            }
            return(ArrayOfTasks);
        }