方法对Java中的数组进行排序

我一直在研究一种方法，可以将数组从最小数排序到最大数。 我提出了下面的代码，但正如您可能猜到的，它没有达到我的预期

我希望采用的逻辑如下：

假设我有一个数组，例如数组{4,3,1,2,5} 例如，代码会将数组[0]（在本例中为4）与数组中的每个元素进行比较

array[0]>array[0] (4>4=false), 
array[0]>array[1] (4>3)= +1counter, 
array[0]>array[2] (4>1)= +1counter, 
array[0]>array[3] (4>2)= +1counter,
array[0]>array[4] (4>5=false)

counter = 3

因此，由于计数器值现在是3，在新数组（array2或arrayOrdered）中，数字4将位于第三个索引中

我该怎么修？非常感谢您的帮助

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

    int[] array2=new int[array.length];

    for (int i=0; i<array.length; i++)
    {
        int place=0;
        for (int j=0; j<array.length;j++)
        {
            if (array[i]> array[j])
            {
                place = place+1;
            }
            array2[place] = array[i];
        }

    }
    return array2;
}

公共静态int[]OrderArray（int[]array）
{
int[]array2=新的int[array.length]；
对于（int i=0；i我没有检查所有的角盒以确保您的逻辑正确，但确保行：

array2[place] = array[i];

应在第二个for块之外。您的代码将覆盖当前array2中所有良好的插入

工作执行：

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

  int[] array2=new int[array.length];
  for (int i=0; i<array.length; i++)
  {
      int place=0;
      for (int j=0; j<array.length;j++)
      {
          if (array[i]> array[j])
          {
              place = place+1;
          }
      }
      array2[place] = array[i];
  }
  return array2;
}

公共静态int[]OrderArray（int[]array）{
int[]array2=新的int[array.length]；
对于使用Java8的（inti=0；i）

import java.util.Arrays;

public class Test {
    public static void main( String[] args ) {
        int[] array = { 2, 1, 3, 5, 4 };
        System.out.println( Arrays.toString( array ) );

        int[] orderedArray = Arrays.stream( array )
            .sorted()
            .toArray();
        System.out.println( Arrays.toString( orderedArray ) );
    }
}

当您准备好决定将其放置在何处时，您应该在确定元素位置的循环之外进行

公共静态int[]OrderArray（int[]array）
{
int[]array2=新的int[array.length]；
对于（int i=0；i，您希望执行的操作称为排序，您可以使用许多具有不同特征的已知排序算法来完成所需的操作

您可以在此处阅读许多不同的排序算法：

Java本身具有内置排序功能，您可以使用
Arrays.sort
方法对数组进行排序，该方法使用非常快速且众所周知的快速排序算法对整数数组进行排序

正如其他评论员所讨论的，您的排序算法似乎有缺陷，总体上看起来与插入排序算法最接近，您可能希望了解一些想法：

插入排序迭代，每次重复使用一个输入元素，
在每次迭代中，插入排序
从输入数据中删除一个元素，查找它所属的位置
在排序的列表中，并将其插入其中。它会重复，直到没有
输入元素仍然存在

来自上述链接的伪代码：

i ← 1
while i < length(A)
    j ← i
    while j > 0 and A[j-1] > A[j]
        swap A[j] and A[j-1]
        j ← j - 1
    end while
    i ← i + 1
end while

i← 1.
而我<长度（A）
J← 我
而j>0和A[j-1]>A[j]
互换A[j]和A[j-1]
J← j-1
结束时
我← i+1
结束时
请注意，堆排序、合并排序或快速排序比问题中使用的排序类型更快

我用第三个数组更新了VMARIESCU的代码，该数组用于处理重复项

public static int[] OrderArray(int[] array){
    int[] array2=new int[array.length];
    int[] stored=new int[array.length];     // used to handle duplicates
    for (int i=0; i<array.length; i++)
    {
        int place=0;
        for (int j=0; j<array.length;j++)
        {
            if (array[i]> array[j])
                place = place+1;
        }
        while(stored[place] != 0)           // skip duplicates
            place += 1;
        array2[place] = array[i];
        stored[place] = 1;
    }
    return array2;
}

公共静态int[]OrderArray（int[]array）{
int[]array2=新的int[array.length]；
int[]stored=new int[array.length]；//用于处理重复项
对于（int i=0；i

publicstaticvoidcyclesort（int a[]）
{
int n=a.长度；
int i，j，p；//用于索引
int e，t；//用于保存数组元素
对于（j=0；j=e
if（a[i]=e
if（a[i]
您不简单地使用数组.sort
？（或者，
IntStream.of（array.sorted（）.toArray（）
，或者许多其他选择之一）（或者，尝试实现一个众所周知的算法）您尝试在这里应用的方法是“计算少于第i个元素的元素数；将第i个元素放在计数第h个位置”。如果输入中的元素相等，则此操作不起作用。如果数组为[4,5,1,2,3]？此算法将给出错误的结果。因此，请从不同的方向思考。正确的实现：“这是不正确的。看我的。你真的能声称一个坏的算法有一个工作的实现吗？实际上不知道。如果不工作，你会怎么称呼它？我试图通过指出逻辑中最大的缺陷来回答“如何修复”的问题。“如果不工作，你会怎么称呼它？”不工作、损坏、不正确、有缺陷等。我会确定地看一看！这是一个家庭作业，所以部分限制不是使用java方法或递归等，但在完成这项工作后，我看到这是多么有用！谢谢！！！哦，我没有考虑重复！谢谢，这段代码非常有用
i ← 1
while i < length(A)
    j ← i
    while j > 0 and A[j-1] > A[j]
        swap A[j] and A[j-1]
        j ← j - 1
    end while
    i ← i + 1
end while

public static int[] OrderArray(int[] array){
    int[] array2=new int[array.length];
    int[] stored=new int[array.length];     // used to handle duplicates
    for (int i=0; i<array.length; i++)
    {
        int place=0;
        for (int j=0; j<array.length;j++)
        {
            if (array[i]> array[j])
                place = place+1;
        }
        while(stored[place] != 0)           // skip duplicates
            place += 1;
        array2[place] = array[i];
        stored[place] = 1;
    }
    return array2;
}

public static void cyclesort(int a[])
{
int n = a.length;
int i, j, p;                            // used for indexing
int e, t;                               // used to hold array elements
    for (j = 0; j < n - 1; j++) {
        e = a[j];                       // e = 1st element of a cycle
        p = j;                          // p = position to store e
        for(i = j+1; i < n; i++){       // advance p to 1st element >= e
            if(a[i] < e)
                p += 1;
        }
        if(p == j)                      // if p not changed, e is in place
            continue;                   //   continue with next element
        while(e == a[p])                // skip any duplicates
            p += 1;
        t = a[p];                       // swap(e, a[p])
        a[p] = e;
        e = t;                          //   e = next element in this cycle
        while(p != j){                  // continue this cycle
            p = j;
            for(i = j+1; i < n; i++){   //   advance p to 1st element >= e
                if(a[i] < e)
                    p += 1;
            }
            while(e == a[p])            //   skip any duplicates
                p += 1;
            t = a[p];                   //   swap(e, a[p])
            a[p] = e;
            e = t;                      //     e = next element in this cycle
        }
    }
}