时代Java，与您同行！关注微信公众号，关注前沿技术，微信搜索：nowjava或时代Java，也可点击这里扫码关注

时代Java

Java 返回从最大值到最小值的排序数组。

欢马劈雪

工程师 (已认证)

原创分享签约作者

发表于实例源码

432

返回从最大值到最小值的排序数组。

实例源码：

源代码：

执行

执行中...

/*来 自 时 代 J a v a 公 众 号 - nowjava.com*/

//package com.nowjava;

public class Main {

public static void main(String[] argv) throws Exception {

double[] v = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,

37.1234, 67.2344, 68.34534, 69.87700 };

System.out.println(java.util.Arrays.toString(sortMaxToMin(v)));

}

/**

* Returns a sorted array from the maximum to the minimum value.

public static double[] sortMaxToMin(double[] v) {

double[] ans = copy(v);

quickSortMaxToMin(ans, 0, ans.length - 1);

return (ans);/**来 自 时   代     Java  公  众  号 - nowjava.com**/

}

/**

* Returns a sorted array from the maximum to the minimum value.

public static int[] sortMaxToMin(int[] v) {

int[] ans = copy(v);

quickSortMaxToMin(ans, 0, ans.length - 1);

return (ans);

}

/**

* Returns a comma delimited string representing the value of the array.

public static String toString(double[] array) {

StringBuffer buf = new StringBuffer(array.length);

int i;

for (i = 0; i < array.length - 1; i++) {

buf.append(array[i]);

buf.append(',');

}

buf.append(array[i]);

return buf.toString();

}

/**

* Returns a comma delimited string representing the value of the array.

public static String toString(double[][] array) {

StringBuffer buf = new StringBuffer();

for (int k = 0; k < array.length; k++) {

buf.append(toString(array[k]));

buf.append(System.getProperty("line.separator"));

}

return buf.toString();

}

/**

* Returns a comma delimited string representing the value of the array.

public static String toString(int[] array) {

StringBuffer buf = new StringBuffer(array.length);

int i;

for (i = 0; i < array.length - 1; i++) {

buf.append(array[i]);

buf.append(',');

}

buf.append(array[i]);

return buf.toString();

}

/**

* Returns a comma delimited string representing the value of the array.

public static String toString(int[][] array) {

StringBuffer buf = new StringBuffer();

for (int k = 0; k < array.length; k++) {

buf.append(toString(array[k]));

buf.append(System.getProperty("line.separator"));

}

return buf.toString();

}

/**

* Returns a copy of the array.

//a call to array.clone() may also work although this is a primitive type. I haven't checked

//it even may be faster

public static int[] copy(int[] array) {

int[] result;

result = new int[array.length];

System.arraycopy(array, 0, result, 0, array.length);

return result;

}

/**

* Returns a copy of the array.

//a call to array.clone() may also work although this is a primitive type. I haven't checked

//it even may be faster

public static long[] copy(long[] array) {

long[] result;

result = new long[array.length];

System.arraycopy(array, 0, result, 0, array.length);

return result;

}

/**

* Returns a copy of the array.

//a call to array.clone() may also work although this is a primitive type. I haven't checked

//it even may be faster

public static float[] copy(float[] array) {

float[] result;

result = new float[array.length];

System.arraycopy(array, 0, result, 0, array.length);

return result;

}

/**

* Returns a copy of the array.

//a call to array.clone() may also work although this is a primitive type. I haven't checked

//it even may be faster

public static double[] copy(double[] array) {

double[] result;

result = new double[array.length];

System.arraycopy(array, 0, result, 0, array.length);

return result;

}

/**

* Returns a copy of the array.

public static double[][] copy(double[][] v) {

double[][] ans = new double[v.length][];

for (int k = 0; k < v.length; k++)

ans[k] = copy(v[k]);

return (ans);

}

/**

* Returns a copy of the array.

public static int[][] copy(int[][] v) {

int[][] ans = new int[v.length][];

for (int k = 0; k < v.length; k++)

ans[k] = copy(v[k]);

return (ans);

}

/**

* This is a generic version of C.A.R Hoare's Quick Sort

* algorithm.  This will handle arrays that are already

* sorted, and arrays with duplicate keys.<BR>

* <p/>

* If you think of a one dimensional array as going from

* the lowest index on the left to the highest index on the right

* then the parameters to this function are lowest index or

* left and highest index or right.  The first time you call

* this function it will be with the parameters 0, a.length - 1.

* (taken out of a code by James Gosling and Kevin A. Smith provided

* with Sun's JDK 1.1.7)

* @param a   an integer array

* @param lo0 left boundary of array partition (inclusive).

* @param hi0 right boundary of array partition (inclusive).

private static void quickSortMaxToMin(int a[], int lo0, int hi0) {

int lo = lo0;

int hi = hi0;

int mid;

if (hi0 > lo0) {

/* Arbitrarily establishing partition element as the midpoint of

* the array.

mid = a[(int) Math.round((lo0 + hi0) / 2.0)];

// loop through the array until indices cross

while (lo <= hi) {

/* find the first element that is greater than or equal to

* the partition element starting from the left Index.

while ((lo < hi0) && (a[lo] > mid))

++lo;

/* find an element that is smaller than or equal to

* the partition element starting from the right Index.

while ((hi > lo0) && (a[hi] < mid))

--hi;

// if the indexes have not crossed, swap

if (lo <= hi) {

swap(a, lo, hi);

++lo;

--hi;

}

/* If the right index has not reached the left side of array

* must now sort the left partition.

if (lo0 < hi)

quickSortMaxToMin(a, lo0, hi);

/* If the left index has not reached the right side of array

* must now sort the right partition.

if (lo < hi0)

quickSortMaxToMin(a, lo, hi0);

}

/**

* This is a generic version of C.A.R Hoare's Quick Sort

* algorithm.  This will handle arrays that are already

* sorted, and arrays with duplicate keys.<BR>

* <p/>

* If you think of a one dimensional array as going from

* the lowest index on the left to the highest index on the right

* then the parameters to this function are lowest index or

* left and highest index or right.  The first time you call

* this function it will be with the parameters 0, a.length - 1.

* (taken out of a code by James Gosling and Kevin A. Smith provided

* with Sun's JDK 1.1.7)

* @param a   a double array

* @param lo0 left boundary of array partition (inclusive).

* @param hi0 right boundary of array partition (inclusive).

private static void quickSortMaxToMin(double a[], int lo0, int hi0) {

int lo = lo0;

int hi = hi0;

double mid;

if (hi0 > lo0) {

/* Arbitrarily establishing partition element as the midpoint of

* the array.

mid = a[(int) Math.round((lo0 + hi0) / 2.0)];

// loop through the array until indices cross

while (lo <= hi) {

/* find the first element that is greater than or equal to

* the partition element starting from the left Index.
/**代码未完, 请加载全部代码(NowJava.com).**/

​x
 
/*来 自 时 代 J a v a 公 众 号 - nowjava.com*/
​
​
//package com.nowjava;
​
​
public class Main {
​
    public static void main(String[] argv) throws Exception {
​
        double[] v = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,
​
                37.1234, 67.2344, 68.34534, 69.87700 };
​
        System.out.println(java.util.Arrays.toString(sortMaxToMin(v)));
​
    }
​
​
    /**
​
     * Returns a sorted array from the maximum to the minimum value.
​
     */
​
    public static double[] sortMaxToMin(double[] v) {
​
        double[] ans = copy(v);
​
        quickSortMaxToMin(ans, 0, ans.length - 1);
​
        return (ans);/**来 自 时   代     Java  公  众  号 - nowjava.com**/
​
    }
​
​
    /**
​
     * Returns a sorted array from the maximum to the minimum value.
​
     */
​
    public static int[] sortMaxToMin(int[] v) {
​
        int[] ans = copy(v);
​
        quickSortMaxToMin(ans, 0, ans.length - 1);
​
        return (ans);
​
    }
​
​
    /**
​
     * Returns a comma delimited string representing the value of the array.
​
     */
​
    public static String toString(double[] array) {
​
​
        StringBuffer buf = new StringBuffer(array.length);
​
        int i;
​
        for (i = 0; i < array.length - 1; i++) {
​
            buf.append(array[i]);
​
            buf.append(',');
​
        }
​
        buf.append(array[i]);
​
        return buf.toString();
​
    }
​
​
    /**
​
     * Returns a comma delimited string representing the value of the array.
​
     */
​
    public static String toString(double[][] array) {
​
        StringBuffer buf = new StringBuffer();
​
        for (int k = 0; k < array.length; k++) {
​
            buf.append(toString(array[k]));
​
            buf.append(System.getProperty("line.separator"));
​
        }
​
        return buf.toString();
​
    }
​
​
    /**
​
     * Returns a comma delimited string representing the value of the array.
​
     */
​
    public static String toString(int[] array) {
​
        StringBuffer buf = new StringBuffer(array.length);
​
        int i;
​
        for (i = 0; i < array.length - 1; i++) {
​
            buf.append(array[i]);
​
            buf.append(',');
​
        }
​
        buf.append(array[i]);
​
        return buf.toString();
​
    }
​
​
    /**
​
     * Returns a comma delimited string representing the value of the array.
​
     */
​
    public static String toString(int[][] array) {
​
        StringBuffer buf = new StringBuffer();
​
        for (int k = 0; k < array.length; k++) {
​
            buf.append(toString(array[k]));
​
            buf.append(System.getProperty("line.separator"));
​
        }
​
        return buf.toString();
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
​
    //it even may be faster
​
    public static int[] copy(int[] array) {
​
        int[] result;
​
        result = new int[array.length];
​
        System.arraycopy(array, 0, result, 0, array.length);
​
        return result;
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
​
    //it even may be faster
​
    public static long[] copy(long[] array) {
​
        long[] result;
​
        result = new long[array.length];
​
        System.arraycopy(array, 0, result, 0, array.length);
​
        return result;
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
​
    //it even may be faster
​
    public static float[] copy(float[] array) {
​
        float[] result;
​
        result = new float[array.length];
​
        System.arraycopy(array, 0, result, 0, array.length);
​
        return result;
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
​
    //it even may be faster
​
    public static double[] copy(double[] array) {
​
        double[] result;
​
        result = new double[array.length];
​
        System.arraycopy(array, 0, result, 0, array.length);
​
        return result;
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    public static double[][] copy(double[][] v) {
​
        double[][] ans = new double[v.length][];
​
        for (int k = 0; k < v.length; k++)
​
            ans[k] = copy(v[k]);
​
        return (ans);
​
    }
​
​
    /**
​
     * Returns a copy of the array.
​
     */
​
    public static int[][] copy(int[][] v) {
​
        int[][] ans = new int[v.length][];
​
        for (int k = 0; k < v.length; k++)
​
            ans[k] = copy(v[k]);
​
        return (ans);
​
    }
​
​
    /**
​
     * This is a generic version of C.A.R Hoare's Quick Sort
​
     * algorithm.  This will handle arrays that are already
​
     * sorted, and arrays with duplicate keys.<BR>
​
     * <p/>
​
     * If you think of a one dimensional array as going from
​
     * the lowest index on the left to the highest index on the right
​
     * then the parameters to this function are lowest index or
​
     * left and highest index or right.  The first time you call
​
     * this function it will be with the parameters 0, a.length - 1.
​
     * (taken out of a code by James Gosling and Kevin A. Smith provided
​
     * with Sun's JDK 1.1.7)
​
     *
​
     * @param a   an integer array
​
     * @param lo0 left boundary of array partition (inclusive).
​
     * @param hi0 right boundary of array partition (inclusive).
​
     */
​
    private static void quickSortMaxToMin(int a[], int lo0, int hi0) {
​
        int lo = lo0;
​
        int hi = hi0;
​
        int mid;
​
​
        if (hi0 > lo0) {
​
​
            /* Arbitrarily establishing partition element as the midpoint of
​
             * the array.
​
             */
​
            mid = a[(int) Math.round((lo0 + hi0) / 2.0)];
​
​
            // loop through the array until indices cross
​
            while (lo <= hi) {
​
                /* find the first element that is greater than or equal to
​
                 * the partition element starting from the left Index.
​
                 */
​
                while ((lo < hi0) && (a[lo] > mid))
​
                    ++lo;
​
​
                /* find an element that is smaller than or equal to
​
                 * the partition element starting from the right Index.
​
                 */
​
                while ((hi > lo0) && (a[hi] < mid))
​
                    --hi;
​
​
                // if the indexes have not crossed, swap
​
                if (lo <= hi) {
​
                    swap(a, lo, hi);
​
                    ++lo;
​
                    --hi;
​
                }
​
            }
​
​
            /* If the right index has not reached the left side of array
​
             * must now sort the left partition.
​
             */
​
            if (lo0 < hi)
​
                quickSortMaxToMin(a, lo0, hi);
​
​
            /* If the left index has not reached the right side of array
​
             * must now sort the right partition.
​
             */
​
            if (lo < hi0)
​
                quickSortMaxToMin(a, lo, hi0);
​
​
        }
​
    }
​
​
    /**
​
     * This is a generic version of C.A.R Hoare's Quick Sort
​
     * algorithm.  This will handle arrays that are already
​
     * sorted, and arrays with duplicate keys.<BR>
​
     * <p/>
​
     * If you think of a one dimensional array as going from
​
     * the lowest index on the left to the highest index on the right
​
     * then the parameters to this function are lowest index or
​
     * left and highest index or right.  The first time you call
​
     * this function it will be with the parameters 0, a.length - 1.
​
     * (taken out of a code by James Gosling and Kevin A. Smith provided
​
     * with Sun's JDK 1.1.7)
​
     *
​
     * @param a   a double array
​
     * @param lo0 left boundary of array partition (inclusive).
​
     * @param hi0 right boundary of array partition (inclusive).
​
     */
​
    private static void quickSortMaxToMin(double a[], int lo0, int hi0) {
​
        int lo = lo0;
​
        int hi = hi0;
​
        double mid;
​
​
        if (hi0 > lo0) {
​
​
            /* Arbitrarily establishing partition element as the midpoint of
​
             * the array.
​
             */
​
            mid = a[(int) Math.round((lo0 + hi0) / 2.0)];
​
​
            // loop through the array until indices cross
​
            while (lo <= hi) {
​
                /* find the first element that is greater than or equal to
​
                 * the partition element starting from the left Index.
/**代码未完, 请加载全部代码(NowJava.com).**/