Java 对新排序算法的建议

我想到了新的排序算法，但我无法理解显而易见的解决方案中的问题：

public int[] sort(int[] arr){

    //Find the biggest number in the array
    int max=1;
    for(int i : arr)
        if(i>max)
            max=i;

    //Sorting the figures into big array
    int[] LongSorted= new int[max+1];
    for(int i=1; i<LongSorted.length; i++)
        LongSorted[i]=0;
    for(int i : arr)
        LongSorted[i]+=i;

    //Transfer the sorted figures into the original array
    int index=0;
    for(int i=0; i<arr.length; i++){
        while(LongSorted[index]==0){
            index++;
        }
        arr[i]=index;
        if(LongSorted[index]!=(index)){
            for(int j=0; j<(LongSorted[index]/index)-1; j++){
                i++;
                arr[i]=index;
            }
        }
        index++;
    }

    return arr;
}

四,。将最后一个中的“i”值更改为“1”。

---

Tnx

如果这本应该是有效的，那就不是了。首先，要多次循环各种数组。其中一些是不必要的，而且它们会降低算法在大数据集上的速度

第二，如果您尝试对以下列表进行排序，会发生什么情况？[1；100000000]

您最终将创建一个大小为10亿+1的数组，用于对两个数字进行排序。这是40亿字节

最后，如果存在重复的元素，会发生什么

然后，正如评论中指出的，这将在负数上失败

如果您完全是自己提出这个想法的，并且是编程新手，那么您实际上已经走上了通往真正重要的事情的正确道路——a

我必须前来救援：

诚然，这很大程度上取决于该算法是否有效，它只覆盖大于0的正值。 但这是一个好主意，在边境案件中可能会非常有效

我将其改写为更易于阅读的内容，仍然保留了适当的排序：

public static int[] sort(int[] arr) {

    // Find the biggest number in the array
    int max = 1;
    for (int i : arr) {
        if (i > max) {
            max = i;
        }
    }

    // Sorting the figures into big array
    // indexOccurrences[i] is how often the value i occures in arr.
    int[] indexOccurrences = new int[max + 1];
    for (int i : arr) {
        ++indexOccurrences[i];
    }

    // Transfer the sorted figures into the original array
    int arrIndex = 0;
    for (int j = 1; j < indexOccurrences.length; ++j) {
        for (int k = 0; k < indexOccurrences[j]; ++k) {
            arr[arrIndex] = j;
            ++arrIndex;
        }
    }
    assert arrIndex == arr.length;
    return arr;
}

public static void main(String[] args) {
    int[] values = new int[] { 23, 6, 67, 6, 6, 45, 3 };
    values = sort(values);
    System.out.println(Arrays.toString(values));
}

[3,6,6,23,45,67]

---

顺便说一句，这个想法并不新鲜，但这可能被视为是对它的支持。

您的alg将在中失败。我们在阵列中有负片。如果您有重复的值，它也将失败。你知道如果数组中有一个大的值，这个算法可能会占用千兆字节的内存吗？让我们对这个数组进行排序{2，Integer.MAX_value-1，1}。它有3个条目。您的行int[]lonsorted=new int[max+1]；将创建一个包含20多亿个条目的数组来对我的3个数字进行排序。这听起来像是在浪费空间。重复的值不是问题。阅读代码的结尾。我将原始元素的索引添加到数组跟踪位置中已经存在的值中。这不是新的。这只是一个非常糟糕的基数排序特例的实现。大约在1988年，ACM SIGPLAN公告中发布了类似于普遍嘲笑的内容。这不是一个真正的问题。实际上，重复项不会被覆盖，它们会丢失并可能创建新值。他将原始元素的索引添加到数组跟踪位置中已有的值中。实际上，我必须自己更正。它甚至更加混乱，并导致未分类的结果。把这个扔掉，用一种经典的方式-事实上，它确实会对正数进行排序并处理重复数，只要您没有包含足够大的数字，大数组就不会占用内存。然而，这是一个可怕的排序实现。

public static int[] sort(int[] arr) {

    // Find the biggest number in the array
    int max = 1;
    for (int i : arr) {
        if (i > max) {
            max = i;
        }
    }

    // Sorting the figures into big array
    // indexOccurrences[i] is how often the value i occures in arr.
    int[] indexOccurrences = new int[max + 1];
    for (int i : arr) {
        ++indexOccurrences[i];
    }

    // Transfer the sorted figures into the original array
    int arrIndex = 0;
    for (int j = 1; j < indexOccurrences.length; ++j) {
        for (int k = 0; k < indexOccurrences[j]; ++k) {
            arr[arrIndex] = j;
            ++arrIndex;
        }
    }
    assert arrIndex == arr.length;
    return arr;
}

public static void main(String[] args) {
    int[] values = new int[] { 23, 6, 67, 6, 6, 45, 3 };
    values = sort(values);
    System.out.println(Arrays.toString(values));
}