Question

我教授的任务之一对我来说特别棘手。我必须用以下标题编写一个方法：

public static void sort(String[] a)

该方法应该按递增的顺序对数组a进行排序（不确定这是否意味着“增加字符串长度的顺序”，但这就是我所假设的）。

问题：我不允许以任何方式更改方法标题，我不允许使用合并排序或快速排序，并且我不允许使用任何无关的包/库。

合并排序和快速排序对我来说并不是什么大不了的事，因为我也不是很喜欢，但我发现很难看到如何做到这一点而不传递一些辅助参数（存储一个将在递归调用中使用的数组的索引位置。

这是我在经历了几个小时的挫折之后得出的，基本上是在转动我的车轮：

public static void sort(String[] a)
{

    String temp;

    // Note that we use a.length - 1 in the loop condition
    // to account for the fact that we will be checking the value of the 
    // element at the current index against the value of the element at the NEXT index.
    // Since array indices are zero-based, iterating from 0 to a.length would result
    // in an ArrayIndexOutOfBoundsException when we index = 7, since the
    // base case would check a[7] against a[8], the latter of which does not exist

    for (int index = 0; index < a.length - 1; index++)
    {
        if (a[index].length() < a[index + 1].length())
        {
            continue;
        }
        else
        {
            temp = a[index + 1];
            a[index + 1] = a[index];
            a[index] = temp;

            // Recursive call to the sort method
            sort(a);
        }
    }
}

基本思想是使用for循环“多次”检查每个元素，以便鼓励每个元素进入其“适当的位置”（在“递增顺序”意义上）。我怀疑这是对的，虽然我还没有测试过（教授还没有上传这个作业的驱动程序）。

如果没有，有人可能会指出我正确的方向吗？似乎在Array或String类中没有任何方法可用于此处。我甚至没有在这里看到递归的用途;如果我只是一遍又一遍地传递同一个数组的方法，那不会没用吗？

Answer 1

此解决方案效率低，因为它涉及创建新数组和复制，但它符合递归必须与提供的方法签名一起使用的要求。它还满足不得使用合并排序和快速排序的要求。

import java.util.Arrays;

public class RecursiveInsertionSort {
    public static void sort(String[] a)
    {
        if (a.length==1) {
            return;
        }
        // Copy array from 1..length-1 into new array rest
        String rest [] = Arrays.copyOfRange(a, 1, a.length);
        // sort rest
        sort(rest);
        // insert a[0] into rest and store the result in a
        insert(a,rest);
    }

    // insert a[0] into sort and store result in a
    private static void insert(String [] a, String [] sorted) {
        int i;
        String saveFirst = a[0];

        // Find index 'i' where such that sorted[i] > a[0]
        for (i=0; i < sorted.length; i++) {
            if (saveFirst.compareTo(sorted[i])<0) {
                break;
            }
        }
        // Copy elements less than a[0] from sorted to a
        for (int j=0; j < i; j++) {
            a[j] = sorted[j];
        }
        // insert a[0]
        a[i] = saveFirst;
        // copy elements greater than a[0] from sorted to a

        for (int j=i+1; j < a.length; j++) {
            a[j] = sorted[j-1];
        }

    }
    public static void main(String args[]) {
        String [] testData = {"Apples", "Oranges", "Cranberries", "Guava" };
        sort(testData);
        for (String s: testData) {
            System.out.println(s);
        }
    }
}

Answer 2

使用（就地）selection sort：

对于数组的每个元素，从头到尾
- 遍历从当前元素到最后一个元素的元素，找到最小的元素（可能是当前元素）
- 将最小的一个与当前的

或（就地）insertion sort：

对于数组的每个元素，从头到尾
- 将前一个元素向右移动，直到当前元素小于刚刚移位的元素并将当前元素放入刚刚创建的间隙中

两者的时间复杂度为O（n ²），但空间复杂度为O（1）。

问题并不是说它必须是递归的。

在没有辅助参数

2 个答案: