写调度算法的一些通用方法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

本人研究生在读，研究生方向为优化算法及其在车间调度算法上的应用。刚开始通过matlab编写程序，最近转Java。编写了一些在写调度算法中常用的方法，方便使用
PS：后续有通用的方法，还会接着更新。

---

方法介绍

list2Array方法用于将List集合转换int数组，代码如下：

 public static int[] list2Array(List<Integer> pi) {
        int[] piNew = new int[pi.size()];
        for (int i = 0; i < pi.size(); i++) {
            piNew[i] = pi.get(i);
        }
        return piNew;
    }

array2List方法用于将int数组转换为List集合，代码如下：

    public static List<Integer> array2List(int[] pi) {
        List<Integer> pii = new LinkedList<>();
        for (int i : pi) {
            pii.add(i);
        }
        return pii;
    }

用List进行排序，用indexof返回下标， jobsum为数组的适应度值大小，piNew为排序的下标值。代码如下：

    	// 相比于map，List需要重新开辟一块地址，且每次执行时，需要遍历一次，增加了O(n)的复杂度
        public static int[] sortArrayGetIndexWithindexof(int[] jobsum) {
        List<Integer> jobsumlist = array2List(jobsum);
        List<Integer> jobsumlist2 = new LinkedList<>();
        jobsumlist2.addAll(jobsumlist);
        Collections.sort(jobsumlist, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        int[] piNew = new int[jobsum.length];
        for (int i = 0; i < jobsum.length; i++) {
            piNew[i] = jobsumlist2.indexOf(jobsumlist.get(i));
        }
        return piNew;
    }

用map存储，根据适应度值返回下标。代码如下：

    public static int[] sortArrayGetIndexWithMap(int[] jobsum, int[] pi) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.length; i++) {
            indexAndValue.put(i, jobsum[i]);
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        int[] pii = new int[pi.length];
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii[i] = integerIntegerEntry.getKey() + 1;
            i++;
        }
        return pii;
    }

按适应度值返回下标，方法重写，下标值用集合传入，适应度值数组传入

 public static int[] sortArrayGetIndexWithMap(int[] jobsum, List<Integer> pi) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.length; i++) {
            indexAndValue.put(i, jobsum[i]);
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        int[] pii = new int[pi.size()];
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii[i] = integerIntegerEntry.getKey() + 1;
            i++;
        }
        return pii;
    }

按适应度值返回下标，方法重写，下标值用数组传入，适应度值用集合传入

    public static int[] sortArrayGetIndexWithMap(List<Integer> jobsum, int[] pi) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.size(); i++) {
            indexAndValue.put(i, jobsum.get(i));
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        int[] pii = new int[pi.length];
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii[i] = integerIntegerEntry.getKey() + 1;
            i++;
        }
        return pii;
    }

按适应度值返回下标，方法重写，下标值和适应度值用集合传入

   public static int[] sortArrayGetIndexWithMap(List<Integer> jobsum, List<Integer> pi) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.size(); i++) {
            indexAndValue.put(i, jobsum.get(i));
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        int[] pii = new int[pi.size()];
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii[i] = integerIntegerEntry.getKey() + 1;
            i++;
        }
        return pii;
    }

返回值为List集合，输入值类型为list

    public static List<Integer> sortArrayGetIndexWithMapGetList(List<Integer> jobsum) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.size(); i++) {
            indexAndValue.put(i, jobsum.get(i));
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        List<Integer> pii = new LinkedList<Integer>();
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii.add(integerIntegerEntry.getKey() + 1);
            i++;
        }
        return pii;
    }

返回值为List集合，输入值类型为int数组

    public static List<Integer> sortArrayGetIndexWithMapGetList(int[] jobsum) {
        Map<Integer, Integer> indexAndValue = new HashMap<>();
        for (int i = 0; i < jobsum.length; i++) {
            indexAndValue.put(i, jobsum[i]);
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(indexAndValue.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, Map.Entry<Integer, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        int i = 0;
        List<Integer> pii = new LinkedList<>();
        for (Map.Entry<Integer, Integer> integerIntegerEntry : list) {
            pii.add(integerIntegerEntry.getKey() + 1);
            i++;
        }
        return pii;
    }

随机产生一列不重复的连续整数

    public static int[] RandPerm(int D) {
        int[] num = new int[D];
        ArrayList<Integer> numTemp = new ArrayList<>();
        for (int i = 0; i < num.length; i++) {
            numTemp.add(i + 1);
        }
        Collections.shuffle(numTemp);
        for (int i = 0; i < num.length; i++) {
            num[i] = numTemp.get(i);
        }
        return num;
    }

将一列数组随机打乱，通过不转集合，不调用shuffle的方法

    public static int[] arrayShuffle(int[] pi){
        int[] pii = Arrays.copyOf(pi, pi.length);
        for (int i = pi.length-1; i > 0; i--) {
            swap(pii, random.nextInt(i),i);
        }
        return pii;
    }

数组元素的交换操作

    public static int[] swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
        return a;
    }

---

总结

在优化算法以及调度操作中，大多是需要进行矩阵运算，因此数组的排序操作以及排序对应的下标尤为重要。再有就是调度中大多为离散操作，int类型的即可。