C# 数字差排序

因此，我试图解决这个任务“数字差异排序”的代码战斗

给定一个整数数组，按其最大和最小数字之差对其元素进行排序。 在平局的情况下，数组中具有较大索引的索引应该排在第一位

范例

对于a=[152,23,7887243]，输出应该是digitDifferenceSort（a）=[7887,23243152]

以下是所有数字的差异：

152：差=5-1=4

23：差=3-2=1

7：差=7-7=0

887：差=8-7=1

243：差=4-2=2

23和887有相同的区别，但887在a中紧跟在23之后，所以在排序数组中它排在第一位

我有一个问题，两个数字有相同的差异。以下是我到目前为止写的内容：

int[] digitDifferenceSort(int[] a) {
    return a.OrderBy(x => difference(x)).ToArray();
}

int difference(int x)
{
    int min = 9, max = 0;
    do
    {
        int tmp = x % 10;
        min = Math.Min(min, tmp);
        max = Math.Max(max, tmp);
    } while ((x /= 10) > 0);

    return max - min;
}

没有做太多（例如，输出仍然是

[7,23887,243,152]

，而不是

[7,887,23243,152]

）

---

如何使索引较大的元素在结果中排在第一位？我应该用什么来代替OrderBy？< /P> < P>我不认为你的代码>差异< /代码>方法，我认为它工作得很好。 对于您的问题：您必须保持数组的尊崇顺序（具有相同差异的项目到达时将被反向排序）。要做到这一点，您可以反转输入数组：所有差异不相同的项都将正确排序，而具有相同差异的项将被反转排序：

int[] digitDifferenceSort(int[] a)
{
     return a.Reverse().OrderBy(x => difference(x)).ToArray();
}

---

<>我不认为你的代码>差异< /代码>方法，我认为它工作得很好。 对于您的问题：您必须保持数组的尊崇顺序（具有相同差异的项目到达时将被反向排序）。要做到这一点，您可以反转输入数组：所有差异不相同的项都将正确排序，而具有相同差异的项将被反转排序：

int[] digitDifferenceSort(int[] a)
{
     return a.Reverse().OrderBy(x => difference(x)).ToArray();
}

---

下面是我对上述问题进行数字差异排序的代码。在Eclipse中运行时，我也会得到输出，但当我将代码粘贴到代码信号上时，它会给我一个空指针异常

package NormalPrograms;

import java.util.ArrayList;
import java.util.Collections;

public class DigitDifferenceSort {
//  For index wise sorting in descending order
    public static int[] sortingnumberindexwise(int[] a, ArrayList<Integer> index) {
        int k = 0;
        int[] res = new int[index.size()];
        int[] finalres = new int[index.size()];
        for (int i = a.length - 1; i >= 0; i--) {
            for (int j = 0; j < index.size(); j++) {
                if (a[i] == (int) index.get(j)) {
                    res[k] = i;
                    index.remove(j);
                    k++;
                    break;
                }
            }
        }
        int g = 0;
        k = 0;
        for (int i = 0; i < res.length; i++) {
            finalres[g] = a[res[k]];
            g++;
            k++;
        }

        return finalres;
    }

    public static int[] finddigitDifferenceandSort(int[] p) {
        int[] finres = new int[p.length];
        for (int i = 0; i < finres.length; i++) {
            finres[i] = p[i];
        }
        // This finres array act as an temp array and reused to make final result array
        int digit = 0;
        ArrayList<Integer> A = new ArrayList<Integer>();
        ArrayList<ArrayList<Integer>> B = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++) {
            B.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < p.length; i++) {
            int temp = 0;
            temp = p[i];
            while (p[i] > 0) {
                digit = p[i] % 10;
                p[i] /= 10;
                A.add(digit);
            }
            int b = Collections.max(A);
            int c = Collections.min(A);
            int diff = b - c;
            B.get(diff).add(temp);
            A.clear();
        }
        for (int i = 0; i < B.size(); i++) {
            if (B.get(i).size() > 1) {
                ArrayList<Integer> C = new ArrayList<Integer>();
                for (int k = 0; k < B.get(i).size(); k++) {
                    C.add(B.get(i).get(k));
                }
                B.get(i).clear();
                for (int j : sortingnumberindexwise(finres, C)) {
                    B.get(i).add(j);
                }
            } else {
                continue;
            }
        }
        int k = 0;
        for (int i = 0; i < B.size(); i++) {
            for (int j = 0; j < B.get(i).size(); j++) {
                if (B.get(i).size() == 0)
                    continue;
                else {
                    finres[k] = B.get(i).get(j);
                    k++;
                }
            }
        }
        return finres;
    }

    public static void main(String[] args) {
        int[] a = { 12, 21, 1, 1, 1, 2, 2, 3 };
        for (int i : finddigitDifferenceandSort(a)) {
            System.out.print(i + " ");
        }
    }
}

打包普通程序；
导入java.util.ArrayList；
导入java.util.Collections；
公共类DigitDifferenceSort{
//用于按降序进行索引排序
公共静态int[]排序编号索引（int[]a，ArrayList索引）{
int k=0；
int[]res=新的int[index.size（）]；
int[]finalres=new int[index.size（）]；
对于（int i=a.length-1；i>=0；i--）{
对于（int j=0；j0）{
数字=p[i]%10；
p[i]/=10；
A.添加（数字）；
}
int b=集合的最大值（A）；
int c=集合的最小值（A）；
int-diff=b-c；
B.获取（差异）、添加（温度）；
A.清除（）；
}
对于（int i=0；i1）{
ArrayList C=新的ArrayList（）；
for（int k=0；k

以下是我对上述问题数字差异排序的代码。在Eclipse中运行时，我也会得到输出，但当我将代码粘贴到代码信号上时，它会给我一个空指针异常

package NormalPrograms;

import java.util.ArrayList;
import java.util.Collections;

public class DigitDifferenceSort {
//  For index wise sorting in descending order
    public static int[] sortingnumberindexwise(int[] a, ArrayList<Integer> index) {
        int k = 0;
        int[] res = new int[index.size()];
        int[] finalres = new int[index.size()];
        for (int i = a.length - 1; i >= 0; i--) {
            for (int j = 0; j < index.size(); j++) {
                if (a[i] == (int) index.get(j)) {
                    res[k] = i;
                    index.remove(j);
                    k++;
                    break;
                }
            }
        }
        int g = 0;
        k = 0;
        for (int i = 0; i < res.length; i++) {
            finalres[g] = a[res[k]];
            g++;
            k++;
        }

        return finalres;
    }

    public static int[] finddigitDifferenceandSort(int[] p) {
        int[] finres = new int[p.length];
        for (int i = 0; i < finres.length; i++) {
            finres[i] = p[i];
        }
        // This finres array act as an temp array and reused to make final result array
        int digit = 0;
        ArrayList<Integer> A = new ArrayList<Integer>();
        ArrayList<ArrayList<Integer>> B = new ArrayList<ArrayList<Integer>>();
        for (int i = 0; i < 10; i++) {
            B.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < p.length; i++) {
            int temp = 0;
            temp = p[i];
            while (p[i] > 0) {
                digit = p[i] % 10;
                p[i] /= 10;
                A.add(digit);
            }
            int b = Collections.max(A);
            int c = Collections.min(A);
            int diff = b - c;
            B.get(diff).add(temp);
            A.clear();
        }
        for (int i = 0; i < B.size(); i++) {
            if (B.get(i).size() > 1) {
                ArrayList<Integer> C = new ArrayList<Integer>();
                for (int k = 0; k < B.get(i).size(); k++) {
                    C.add(B.get(i).get(k));
                }
                B.get(i).clear();
                for (int j : sortingnumberindexwise(finres, C)) {
                    B.get(i).add(j);
                }
            } else {
                continue;
            }
        }
        int k = 0;
        for (int i = 0; i < B.size(); i++) {
            for (int j = 0; j < B.get(i).size(); j++) {
                if (B.get(i).size() == 0)
                    continue;
                else {
                    finres[k] = B.get(i).get(j);
                    k++;
                }
            }
        }
        return finres;
    }

    public static void main(String[] args) {
        int[] a = { 12, 21, 1, 1, 1, 2, 2, 3 };
        for (int i : finddigitDifferenceandSort(a)) {
            System.out.print(i + " ");
        }
    }
}

打包普通程序；
导入java.util.ArrayList；
导入java.util.Collections；
公共类DigitDifferenceSort{
//用于按降序进行索引排序
公共静态int[]排序编号索引（int[]a，ArrayList索引）{
int k=0；
int[]res=新的int[index.size（）]；
int[]finalres=new int[index.size（）]；
对于（int i=a.length-1；i>=0；i--）{
对于（int j=0；j