Java——使10个整数排序程序递归

我有一个简单的问题-我需要订购10个号码。我有一个递归的方法：制作一个10个数字的数组，取10个数字中的最大值，从数组中取出，用剩下的9个数字重复相同的函数。问题是我不知道如何实现这一点。我写了这个程序，它可以工作，只是它有一个部分可以一直重复，但是有新的数组，因为你不能改变数组的大小

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone {
    public static void main (String[] args) throws java.lang.Exception {
        int[] sortedArray = new int[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

        Scanner input = new Scanner(System.in);
        int in0 = input.nextInt();
        int in1 = input.nextInt();
        int in2 = input.nextInt();
        int in3 = input.nextInt();
        int in4 = input.nextInt();
        int in5 = input.nextInt();
        int in6 = input.nextInt();
        int in7 = input.nextInt();
        int in8 = input.nextInt();
        int in9 = input.nextInt();

        int[] numArray = new int[]{in0, in1, in2, in3, in4, in5, in6, in7, in8, in9};

        int numArrayLength = numArray.length;
        recursiveSort(numArray);
        for (int i=0;i<numArrayLength;i++) {
            System.out.print(numArray[i]+",");
        }
        sortedArray[0] = numArray[0];
        System.out.println(" ");

        int[] numArray2 = Arrays.copyOfRange(numArray, 1, numArrayLength);
        int numArray2Length = numArray2.length;
        recursiveSort(numArray2);
        for (int j=0;j<numArray2Length;j++) {
            System.out.print(numArray2[j]+",");
        }
        sortedArray[1] = numArray2[0];
        System.out.println(" ");

        int[] numArray3 = Arrays.copyOfRange(numArray2, 1, numArray2Length);
        int numArray3Length = numArray3.length;
        recursiveSort(numArray3);
        for (int k=0;k<numArray3Length;k++) {
            System.out.print(numArray3[k]+",");
        }
        sortedArray[2] = numArray3[0];
        System.out.println(" ");

        int[] numArray4 = Arrays.copyOfRange(numArray3, 1, numArray3Length);
        int numArray4Length = numArray4.length;
        recursiveSort(numArray4);
        for (int k=0;k<numArray4Length;k++) {
            System.out.print(numArray4[k]+",");
        }
        sortedArray[3] = numArray4[0];
        System.out.println(" ");

        int[] numArray5 = Arrays.copyOfRange(numArray4, 1, numArray4Length);
        int numArray5Length = numArray5.length;
        recursiveSort(numArray5);
        for (int k=0;k<numArray5Length;k++) {
            System.out.print(numArray5[k]+",");
        }
        sortedArray[4] = numArray5[0];
        System.out.println(" ");

        int[] numArray6 = Arrays.copyOfRange(numArray5, 1, numArray5Length);
        int numArray6Length = numArray6.length;
        recursiveSort(numArray6);
        for (int k=0;k<numArray6Length;k++) {
            System.out.print(numArray6[k]+",");
        }
        sortedArray[5] = numArray6[0];
        System.out.println(" ");

        int[] numArray7 = Arrays.copyOfRange(numArray6, 1, numArray6Length);
        int numArray7Length = numArray7.length;
        recursiveSort(numArray7);
        for (int k=0;k<numArray7Length;k++) {
            System.out.print(numArray7[k]+",");
        }
        sortedArray[6] = numArray7[0];
        System.out.println(" ");

        int[] numArray8 = Arrays.copyOfRange(numArray7, 1, numArray7Length);
        int numArray8Length = numArray8.length;
        recursiveSort(numArray8);
        for (int k=0;k<numArray8Length;k++) {
            System.out.print(numArray8[k]+",");
        }
        sortedArray[7] = numArray8[0];
        System.out.println(" ");

        int[] numArray9 = Arrays.copyOfRange(numArray8, 1, numArray8Length);
        int numArray9Length = numArray9.length;
        recursiveSort(numArray9);
        for (int k=0;k<numArray9Length;k++) {
            System.out.print(numArray9[k]+",");
        }
        sortedArray[8] = numArray9[0];
        System.out.println(" ");

        int[] numArray10 = Arrays.copyOfRange(numArray9, 1, numArray9Length);
        int numArray10Length = numArray10.length;
        recursiveSort(numArray10);
        for (int k=0;k<numArray10Length;k++) {
            System.out.print(numArray10[k]+",");
        }
        sortedArray[9] = numArray10[0];
        System.out.println(" ");

        sortedArray[2] = numArray3[0];
        for (int dasdasd=0;dasdasd<sortedArray.length;dasdasd++) {
            System.out.print(sortedArray[dasdasd]+",");
        }
    }
    private static int[] recursiveSort(int numArray[]) {
        int numArrayLength = numArray.length;
        int maximum = 0;
        for (int i=0;i<numArrayLength;i++) {
            if (numArray[i] > maximum) {
                maximum = numArray[i];
            }
        }

        int indexOfMaximum = -1;

        for (int j=0;j<numArrayLength;j++) {
            if (numArray[j] == maximum) {
                indexOfMaximum = j;
                break;
            }
        }

        int temporary = numArray[0];
        numArray[0] = numArray[indexOfMaximum];
        numArray[indexOfMaximum] = temporary;
        return numArray;
    }
}

/*打包任何内容；//不要放置包名*/
导入java.util.*；
导入java.lang.*；
导入java.io.*；
/*只有当类是公共的时，类的名称才必须是“Main”*/
表意文字{
公共静态void main（字符串[]args）引发java.lang.Exception{
int[]sortedArray=新的int[]{0,0,0,0,0,0,0,0}；
扫描仪输入=新扫描仪（System.in）；
int in0=input.nextInt（）；
int in1=input.nextInt（）；
int in2=input.nextInt（）；
int in3=input.nextInt（）；
int in4=input.nextInt（）；
int in5=input.nextInt（）；
int in6=input.nextInt（）；
int in7=input.nextInt（）；
int in8=input.nextInt（）；
int in9=input.nextInt（）；
int[]numaray=newint[]{in0，in1，in2，in3，in4，in5，in6，in7，in8，in9}；
int numArray长度=numArray.length；
递归排序（numArray）；
对于（int i=0；i我建议使用一个递归例程，该例程对仍需排序的部分使用显式的开始索引：

private static void recursiveSort(int[] array, int start) {
    if (start < array.length - 1) {
        int maximum = array[start];
        int maximumIndex = start;
        for (int i = start + 1; i < array.length; ++i) {
            if (array[i] > maximum) {
                maximum = array[i];
                maximumIndex = i;
            }
        }
        if (maximumIndex != start) {
            int tmp = array[start];
            array[start] = array[maximumIndex];
            array[maximumIndex] = tmp;
        }
        recursiveSort(array, start + 1);
    }
}

当它返回时，数组将按降序排序

作为一个通用的启发式算法，当你在如何使一个方法递归时遇到困难时，你应该考虑向方法添加参数来帮助记帐。
 < P>我建议一个递归例程，该程序使用一个显式的开始索引来对要排序的部分：

private static void recursiveSort(int[] array, int start) {
    if (start < array.length - 1) {
        int maximum = array[start];
        int maximumIndex = start;
        for (int i = start + 1; i < array.length; ++i) {
            if (array[i] > maximum) {
                maximum = array[i];
                maximumIndex = i;
            }
        }
        if (maximumIndex != start) {
            int tmp = array[start];
            array[start] = array[maximumIndex];
            array[maximumIndex] = tmp;
        }
        recursiveSort(array, start + 1);
    }
}

当它返回时，数组将按降序排序

作为一个一般的启发式算法，当你在如何使递归方法挣扎时，你应该考虑增加对方法的帮助以帮助记帐。< /P> < P>是这个作业还是你需要数字排序？如果你使用<代码> ARAYLISH（）/CUT>而不是

。您只需要调用

集合。排序（yourArrayList）；

这是家庭作业还是您只需要对数字进行排序？如果您使用

ArrayList（）

而不是

数组[]

，Java有一种简单的方法可以做到这一点。您只需要调用

集合。排序（yourArrayList）；

我建议不要尝试自己制作排序算法。许多聪明人已经为你做了这项艰巨的工作

您尝试实现的“递归”排序（也称为气泡排序，Ted已经向您展示了如何真正实现递归）将起作用，但效率极低。请参阅排序算法的比较

下面是您尝试实现的算法的演示，与shell sort相比，shell sort是可用的最快的排序算法之一。我使用的实现取自。运行它，您将看到shell sort平均比bubble sort快7到8倍

public class SortingDemo {
    // Methods required for Shell sort
    public static void shellSort(Comparable[] a) {
        int N = a.length;
        int h = 1;
        while (h < N/3) h = 3*h + 1;

        while (h >= 1) {
            for (int i = h; i < N; i++) {
                for (int j = i; j >= h && less(a[j], a[j-h]); j -= h) {
                    exch(a, j, j-h);
                }
            }
            assert isHsorted(a, h); 
            h /= 3;
        }
        assert isSorted(a);
    }

    private static boolean less(Comparable v, Comparable w) {
        return (v.compareTo(w) < 0);
    }

    private static void exch(Object[] a, int i, int j) {
        Object swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    private static boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++)
            if (less(a[i], a[i-1])) return false;
        return true;
    }

    private static boolean isHsorted(Comparable[] a, int h) {
        for (int i = h; i < a.length; i++)
            if (less(a[i], a[i-h])) return false;
        return true;
    }

    // Method required for "recursive" sort
    private static void recursiveSort(Integer[] array, int start) {
        if (start < array.length - 1) {
            int maximum = array[start];
            int maximumIndex = start;
            for (int i = start + 1; i < array.length; ++i) {
                if (array[i] > maximum) {
                    maximum = array[i];
                    maximumIndex = i;
                }
            }
            if (maximumIndex != start) {
                int tmp = array[start];
                array[start] = array[maximumIndex];
                array[maximumIndex] = tmp;
            }
            recursiveSort(array, start + 1);
        }
    }

    public static void main(String[] args) {
        int desiredArraySize = 1000;
        int minSizeOfNumberInArray = 0;
        int maxSizeOfNumberInArray = 100;
        Integer[] array = new Integer[desiredArraySize]; // Used Integer instead of int to utilize Comparable interface
        for(int i = 0; i < array.length; i++) {
            int randomInt = (int) Math.random() * (maxSizeOfNumberInArray - minSizeOfNumberInArray);
            array[i] = randomInt;
        }

        long startTime = System.nanoTime();
        recursiveSort(array, 0);
        long endTime = System.nanoTime();
        long recursiveSortTime = endTime - startTime;
        System.out.println(String.format("\"Recursive\" sort completed in %d ns", recursiveSortTime));

        startTime = System.nanoTime();
        shellSort(array);
        endTime = System.nanoTime();
        long shellSortTime = endTime - startTime;
        System.out.println(String.format("Shell sort completed in %d ns", shellSortTime));

        System.out.println(String.format("\"Recursive\" sort took %f times longer", (float)recursiveSortTime / (float)shellSortTime));
    }
}

公共类排序演示{
//Shell排序所需的方法
公共静态空壳排序（可比[]a）{
int N=a.长度；
int h=1；
而（h=1）{
对于（int i=h；i=h&&less（a[j]，a[j-h]）；j-=h）{
exch（a，j，j-h）；
}
}
（a，h）；
h/=3；
}
断言分类（a）；
}
私有静态布尔值小于（可比v，可比w）{
返回值（v.compareTo（w）<0）；
}
私有静态void exch（对象[]a，int i，int j）{
对象交换=a[i]；
a[i]=a[j]；
a[j]=互换；
}
私有静态布尔isSorted（可比[]a）{
for（int i=1；i最大值）{
最大值=数组[i]；
最大指数=i；
}
}
如果（最大索引！=开始）{
int tmp=数组[开始]；
数组[start]=数组[maximumIndex]；
数组[maximumIndex]=tmp；
}
递归排序（数组，开始+1）；
}
}
公共静态void main（字符串[]args）{
int desiredArraySize=1000；
int minSizeOfNumberInArray=0；
int maxSizeOfNumberInArray=100；
整数[]数组=新整数[desiredArraySize]；//使用整数而不是int来利用可比较的接口
for（int i=0；ipublic class SortingDemo {
    // Methods required for Shell sort
    public static void shellSort(Comparable[] a) {
        int N = a.length;
        int h = 1;
        while (h < N/3) h = 3*h + 1;

        while (h >= 1) {
            for (int i = h; i < N; i++) {
                for (int j = i; j >= h && less(a[j], a[j-h]); j -= h) {
                    exch(a, j, j-h);
                }
            }
            assert isHsorted(a, h); 
            h /= 3;
        }
        assert isSorted(a);
    }

    private static boolean less(Comparable v, Comparable w) {
        return (v.compareTo(w) < 0);
    }

    private static void exch(Object[] a, int i, int j) {
        Object swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }

    private static boolean isSorted(Comparable[] a) {
        for (int i = 1; i < a.length; i++)
            if (less(a[i], a[i-1])) return false;
        return true;
    }

    private static boolean isHsorted(Comparable[] a, int h) {
        for (int i = h; i < a.length; i++)
            if (less(a[i], a[i-h])) return false;
        return true;
    }

    // Method required for "recursive" sort
    private static void recursiveSort(Integer[] array, int start) {
        if (start < array.length - 1) {
            int maximum = array[start];
            int maximumIndex = start;
            for (int i = start + 1; i < array.length; ++i) {
                if (array[i] > maximum) {
                    maximum = array[i];
                    maximumIndex = i;
                }
            }
            if (maximumIndex != start) {
                int tmp = array[start];
                array[start] = array[maximumIndex];
                array[maximumIndex] = tmp;
            }
            recursiveSort(array, start + 1);
        }
    }

    public static void main(String[] args) {
        int desiredArraySize = 1000;
        int minSizeOfNumberInArray = 0;
        int maxSizeOfNumberInArray = 100;
        Integer[] array = new Integer[desiredArraySize]; // Used Integer instead of int to utilize Comparable interface
        for(int i = 0; i < array.length; i++) {
            int randomInt = (int) Math.random() * (maxSizeOfNumberInArray - minSizeOfNumberInArray);
            array[i] = randomInt;
        }

        long startTime = System.nanoTime();
        recursiveSort(array, 0);
        long endTime = System.nanoTime();
        long recursiveSortTime = endTime - startTime;
        System.out.println(String.format("\"Recursive\" sort completed in %d ns", recursiveSortTime));

        startTime = System.nanoTime();
        shellSort(array);
        endTime = System.nanoTime();
        long shellSortTime = endTime - startTime;
        System.out.println(String.format("Shell sort completed in %d ns", shellSortTime));

        System.out.println(String.format("\"Recursive\" sort took %f times longer", (float)recursiveSortTime / (float)shellSortTime));
    }
}