带置换的数组的Insertionsort（Java）

Question

所以我有一个数组，我必须用insertionsort进行排序：

( 4 1 2 3 )= arr[0] ,
( 1 2 3 4 )=arr[1] ,
( 4 3 2 1 ) = arr[2], 
( 3 1 2 4 )= arr[3] ,
( 4 3 1 2 ) = arr[4] ,
( 2 1 3 4 ) = arr[5] ,
( 4 1 3 2 ) = arr[6] ,
( 1 4 2 3 )= arr[7] 

如果数组1的值1-4与数组2的值1-4之间的差值较大，则一个数组将与另一个数组交换。例如：arr[0]<；arr[1]，因为1（4-3）<；3(4-1). 如果差值相同，则将比较这些值：例如：arr[5]&；arr[6]具有相同的差异（2），但arr[6]。价值（1）>；arr[5]。价值（1）——>；交换

因此，排序后的数组将如下所示：

(3,1,2,4) < (4,1,2,3) < (1,4,2,3) < (2,1,3,4) < (4,1,3,2) < (4,3,1,2) < (1,2,3,4) < (4,3,2,1)

我有一个methode atm，其中只检查了第一个标准：

public int insertionsort(permutation[] arr, int gap) {
            int count = 0;
                for (int i = gap; i<arr.length-1; i++) {
                    count++;
                    permutation new = arr[i];
                    int k = i;
                    System.out.println("K: " + k);
                    System.out.println("gap: "+ gap);
                    while(Math.abs(arr[i].value(1)-arr[i].value(4)) > Math.abs(arr[i-gap].value(1) - 
                    arr[i-gap].value(4))) {
                        arr[k] = arr[k-gap];
                        k = k-gap;
                        System.out.println("k-gap: " + (k-gap));
                    }
                    arr[k] = new;
                }

        return count;
        } 

现在我想我的数组应该先按照微小差异的顺序进行排序，但它似乎不正确。我希望你能帮助我

Answer 1

我不清楚gap参数的目的是什么，希望您可以在需要时将其合并，但是这里有一个标准Insertion Sort方法到Java的直接翻译

static void sort(permutation[] perms)
{
    for(int i=1; i<perms.length; i++)
    {
        permutation fixed = perms[i];
        int j = i - 1;
        while(j >= 0 && perms[j].compareTo(fixed) > 0)
        {
            perms[j+1] = perms[j];
            j -= 1;
        }
        perms[j+1] = fixed;
    }
}

猜测一下permutation类可能是什么样子：

static class permutation
{
    int len;
    int[] arr;

    public permutation(int... vals)
    {
        len = vals.length;
        arr = vals.clone();
    }

    int value(int pos) 
    {
        return arr[pos-1];
    }

    public int compareTo(permutation p)
    {
        int cmp = Math.abs(value(1)-value(len)) - Math.abs(p.value(1)-p.value(len));
        if(cmp == 0)
            for(int i=1; cmp==0 && i<=len; i++)
                cmp = value(i)-p.value(i);
        return cmp;
    }
}

测试：

permutation[] perms = {
        new permutation(4,1,2,3),
        new permutation(1,2,3,4),
        new permutation(4,3,2,1),
        new permutation(3,1,2,4),
        new permutation(4,3,1,2),
        new permutation(2,1,3,4),
        new permutation(4,1,3,2),
        new permutation(1,4,3,2)
};

sort(perms);

for(permutation p : perms)
    System.out.println(Arrays.toString(p.arr));

输出：

[1, 4, 3, 2]
[3, 1, 2, 4]
[4, 1, 2, 3]
[2, 1, 3, 4]
[4, 1, 3, 2]
[4, 3, 1, 2]
[1, 2, 3, 4]
[4, 3, 2, 1]