Question

所以我可以为此使用标准数组，没有别的。我必须找到一种方法来创建一个方法来查找给定排列中的所有循环，并将它们作为数组的数组对象返回。然后我必须将每个数组的最低位置作为数组的第一个条目。然后按最低排序。

我不能使用arraylists或集合或任何东西。

编辑：循环我的意思是取初始对象的整数值并找到它对应的索引值。在该索引处获取该整数值并执行相同操作。继续这样做，直到它指向已经被引用的对象。

示例：[0, 4, 2, 8, 7, 9, 1, 6, 5, 3]

将是这些周期：[0] [4, 8, 5, 7, 6, 9, 3, 2] [1]

并返回：[0], [1], [2, 4, 8, 5, 7, 6, 9, 3]

或

此数组：[2, 4, 8, 1, 5, 3, 9, 0, 7, 6]

将是这些周期：[2, 8, 7, 0] [4, 5, 3, 1] [9, 6]

并返回：[0, 2, 8, 7], [1, 4, 5, 3], [6, 9]

我迷失了，任何帮助都会很精彩。提前谢谢！

Answer 1

不要问我为什么要花时间做这件事。

编辑：现在完全正常工作

public class Main {

    public Main()
    {

    }

    public static void main(String[] args)
    {
        int array[] = {0, 4, 2, 8, 7, 9, 1, 6, 5, 3};
        Main m = new Main();
        int[][] cycles = m.getCycles(array);
        for (int i = 0; i < cycles.length; i++)
        {
            System.out.print("[");
            for (int j = 0; j < cycles[i].length; j++)
            {
                System.out.print(cycles[i][j]);
                if (j < cycles[i].length - 1)
                    System.out.print(", ");
            }
            System.out.println("]");
        }
        System.out.println("end debug");
    }

    public int[][] getCycles(int[] array)
    {
        int[][] cycles = new int[array.length][array.length];

        // initialize the cycles to all -1s, cuz they'll never be in the array
        for (int i = 0; i < cycles.length; i++)
        {
            for (int j = 0; j < cycles[i].length; j++)
            {
                cycles[i][j] = -1;
            }
        }

        int i = 0;

        do {
            int nextElement = array[i];

            int j = 0;
            do {
                cycles[i][j] = nextElement;
                nextElement = array[nextElement];
                j++;
            } while (!elementInArray(cycles[i], nextElement) && j < array.length);


            i++;
        }  while (!arrayHasCycled(array, cycles) && i < array.length);


        cycles = removeNegativeOnes(cycles, i);

        for (i = 0; i < cycles.length; i++)
        {
            pushForward(cycles[i]);
        }

        return cycles;
    }

    public boolean elementInArray(int[] array, int element)
    {
        for (int i = 0; i < array.length; i++)
        {
            if( array[i] == element)
                return true;
        }

        return false;
    }

    public int[][] removeNegativeOnes(int[][] cycles, int numCycles)
    {
        int [][] newCycles = new int[numCycles][];
        for (int i = 0; i < numCycles; i++)
        {
            int realLenOfCycle = indexOf(-1, cycles[i]);
            newCycles[i] =  new int[realLenOfCycle];
            for (int j = 0; j < newCycles[i].length; j++)
            {
                newCycles[i][j] = cycles[i][j];
            }
        }

        return  newCycles;
    }

    public int indexOf(int element, int[] array)
    {
        int index =  -1;

        for (int i = 0; i < array.length; i++)
        {
            if (array[i] == element)
                return i;
        }

        return index;
    }

    public boolean arrayHasCycled(int[] array, int[][] cycles)
    {
        for (int i = 0; i < array.length; i++)
        {
            boolean cycleHasValue = false;
            for (int j = 0; j < cycles.length; j++)
            {
                for (int k = 0; k < cycles[j].length; k++)
                {
                    if (cycles[j][k] == array[i])
                        cycleHasValue = true;
                }
            }
            if (!cycleHasValue)
                return false;
        }

        return true;
    }

    public void pushForward(int [] array)
    {
        int lastElement = array[array.length - 1];
        for (int i = array.length - 1; i > 0; i--)
        {
            array[i] = array[i - 1];
        }

        array[0] = lastElement;
    }
}

输出：

[0]
[1, 4, 7, 6]
[2]
[3, 8, 5, 9]

根据我的理解，我们要求您创建一个执行以下算法的代码：

创建一个整数的一维数组array
对于该数组中的每个元素，nextElement执行以下操作：
创建一个新的一维数组，currCycle将添加到二维数组cycles。
将该数组的第一个元素设置为nextElement。
nextElement然后变为array[nextElement]
如果nextElement已在currCycle中，请继续查看array的下一个元素
检查array的所有元素是否都在cycles，如果是，请停止执行此算法。
最后，将循环作为二维数组返回，使用正在使用的索引而不是该索引处的元素，这是当前数组所包含的。为了实现这一点，只需循环（在正常意义上）将数组的每个元素推向一个索引。

这并不完全符合您的示例，但我认为您的示例可能不正确，例如：

一个例子：[0,4,2,8,7,9,1,6,5,3]

将是这些周期：[0] [4,8,5,7,6,9,3,2] [1]

并返回：[0]，[1]，[2,4,8,5,7,6,9,3]

第一个元素0是0，所以当你得到0时，它已经在当前周期中，所以转到下一个元素，即索引1处的元素，即4.一旦你在4，转到第四个元素，这是7而不是8！

 0  1  2  3  4
[0, 4, 2, 8, 7...

使用数组数组（int [] []），创建一个方法来查找给定排列中的所有循环

1 个答案: