Цикл сортировки Java не работает

Question

. В основном, что делает следующий код (предположим), создайте набор неповторяющихся случайных чисел, заполните их до массива, который преобразуется в список и сортирует их. Проблема заключается в вложенных циклах, я управлял работой, но даже не уверен, как она работает. Во-вторых, я наклоняю, кажется, сортирую его правильно, время от времени появляются повторяющиеся ошибки и ошибки.

Как работает код:

1. Генерация неповторяющихся случайных чисел
2. Заполнить массив с ними
3. Использование вложенных для цикла, чтобы найти наименьшее значение
4. Вставить, что в новый массив
5. Удалить его из первого массива

6. Повторите последние 2 шага, пока первый массив не будет пустым и вторым Массив ОС заливается в упорядоченном

   import org.apache.commons.lang.ArrayUtils; 
   import java.util.ArrayList; 
   import java.util.Arrays; 
   import java.util.*; 
   import java.lang.*; 
   import java.io.*; 
   
   public class Sorter { 
   
   public static void main(String[] args) { 
   int[] process = fillArray(20,1,25); 
   sorter(process,20); 
   
   } 
   
   public static int[] sorter(int array[],int size) { 
   
   int[] useArray = array; 
   
   Integer[] newArray = ArrayUtils.toObject(useArray); 
   List<Integer> arrayList = new ArrayList(Arrays.asList(newArray)); 
   
   
   //System.out.println((arrayList)); 
   
   int counter = 1; 
   int minval = 0; 
   int diffsize = size - 1; 
   int actualVal = 0; 
   int storeArray[] = new int[size]; 
   int removeIndex =0; 
   
   Integer[] newStore = ArrayUtils.toObject(storeArray); 
   List<Integer> storeList = new ArrayList(Arrays.asList(newStore)); 
   
   System.out.println((arrayList)); 
   
   // Both loops messed up 
   for (int i = 0; i < size+diffsize; i++) { 
   
       for (int n = 0; n < size-1; n++) { 
   
        if (arrayList.get(minval) < arrayList.get(counter)) { 
         actualVal = arrayList.get(minval); 
         System.out.println((arrayList.get(minval)) + " Less than " + arrayList.get(counter)); 
         counter = counter + 1; 
         removeIndex = minval; 
        } else { 
         actualVal = arrayList.get(counter); 
         System.out.println((arrayList.get(counter)) + " Less than " + arrayList.get(minval)); 
         minval = counter; 
         counter = counter + 1; 
         removeIndex = counter; 
        } 
       } 
   
       // System.out.println(actualVal); 
       storeList.add(actualVal); 
       arrayList.remove(actualVal); // need to remove the smallest value to repeat the sorting and get the next smallest value, but this is not removing it 
       size = size - 1; 
       counter = 1; 
       minval = 0; 
       // if (i + size == i) { 
       //  storeList.set(i, arrayList.get(0)); 
       // } 
       // System.out.println(removeIndex); 
   
       // System.out.println(arrayList); 
   } 
   
   
       // System.out.println(storeList); 
   
        int[] ints = new int[storeList.size()]; 
        int d = 0; 
        for (Integer u : storeList) { 
        ints[d++] = u; 
        } 
   
   
       return ints; 
   } 
   
   
       public static int randomNum(int lower,int upper){ 
       Random rand = new Random(); 
       int randomNum = lower + rand.nextInt((upper- lower) + 1); 
       return randomNum; 
   } 
   
   
   
   
   public static int[] fillArray(int size,int lowerBound,int upperBound){ 
       int holdArray[] = new int[size]; 
   
       int rand = 0; 
   
       for (int count =0;count < holdArray.length;count++){ 
        holdArray[count] = 0; 
       } 
   
       for (int count =0;count < holdArray.length;count++){ 
   
        rand = randomNum(lowerBound,upperBound); 
        if (ArrayUtils.contains(holdArray, rand)) { 
         while (ArrayUtils.contains(holdArray, rand)) { 
         rand = randomNum(0, 20); 
        } 
       } 
       holdArray[count] = rand; 
   } 
       // System.out.println(Arrays.toString(holdArray)); 
   
   //return holdArray; 
   
   return holdArray; 
   
   } 
   
   
   
   } 
   

Answer 1

Можете ли вы дать веские основания для обоснования преобразования из массива в список? почему бы не использовать только список или только массив? Я использую ArrayList в своем ответе ниже;

Первый, класс fillArray. Вам не нужно заполнять все нули.Почему даже потрудитесь заполнить его значением, которое вы все равно замените?

public static ArrayList<Integer> fillArray(int size,int lowerBound,int upperBound){ 
    ArrayList<Integer> a = new ArrayList<Integer>(size); 
    for (int count =0;count < size;count++){ 
     Integer rand = new Integer(randomNum(lowerBound,upperBound)); 
     a.add(rand); 
    } 
    return a; 
} 

Во-вторых, сортировка класса. Ваш метод, как вы сказали, поиск наименьшего значения, а затем волшебный материал, а что нет.

public static ArrayList<Integer> sorter(ArrayList<Integer> unsorted) { 
ArrayList<Integer> sortedArray = new ArrayList<Integer>(unsorted.size()); 
while(!unsorted.isEmpty()) { //repeats until the unsorted list is empty 
    int minval = unsorted.get(0); 
    int removeIndex = 0; 
    for(int i=1;i<unsorted.size();i++) 
     if (unsorted.get(i)<minval) { 
      minval = unsorted.get(i); 
      removeIndex = i; 
     } 
    sortedArray.add(minval); 
    unsorted.remove(removeIndex); 
    } 
    return sortedArray; 
} 

основной метод, чтобы проверить его

public static void main(String[] args) { 
    ArrayList<Integer> a = fillArray(20,1,25); 
    System.out.println("unsorted array"); 
    for (Integer c : a) 
     System.out.print(c + ";"); 
    ArrayList<Integer> b = sorter(a); 
    System.out.println("\nnew unsorted array"); 
    for (Integer c : a) 
     System.out.print(c + ";"); 
    System.out.println("\nsorted array"); 
    for (Integer c : b) 
     System.out.print(c + ";"); 
} 

это выводит

unsorted array 
22;2;23;22;13;12;4;1;7;14;25;18;9;12;3;8;20;3;1;20; 
new unsorted array 

sorted array 
1;1;2;3;3;4;7;8;9;12;12;13;14;18;20;20;22;22;23;25; 

Answer 2

Выделим «найти наименьший» и «вставки/удаления» из массивов на два метода, а затем использовать их.

Таким образом, код будет более управляемым. Ниже приведен пример метода find_min.

int find_min(int[] array, int start) { 
    int min = Integer.MAX_VALUE; 
    for(int i = start; i < array.length; ++i) 
     if(array[i] < min) 
      min = array[i] ; 
    return min; 
} 

Сейчас в сортировочной рутине, используйте find_min найти минимальный элемент и вставить его в новый массив, а затем удалить минимальный элемент из исходного массива. Однако этот метод не возвращает индекс минимального элемента. Поэтому я предлагаю вам изменить его, чтобы вернуть индекс и элемент в виде пары значений int.

Ваша сортировка процедура будет выглядеть следующим образом:

new_array := [] 
while(length(original_array) > 0) 
    min, min_index := find_min(original_array) 
    new_array.append(min) 
    original_array.delete(min_index) 

Вы можете использовать что-то вроде этого, чтобы вернуть int пару:

class IntPair { 
    int min; 
    int index; 

    public IntPair(int x, int y) { this.min=x; this.index=y; } 

    public int get_min() { return min; } 
    public int get_min_index() { return index; } 
} 

Кроме того, так как вы будете де делать вставки и удаления, используйте ArrayList вместо этого. Он имеет методы для удаления элемента по определенному индексу и добавления к нему элементов.

Примечание: Ваш подход, изложенный близок к Selection Sort алгоритма, в котором мы делим массив на две части (сортируется левой части и несортированный правой части) и многократно выбирать наименьший элемент справа от массива и поменять его с правый элемент левой части.

min := array[0] 
for(i := 0; i < array.length; ++i) 
    for(j := i+1; j < array.length; ++j) 
     if(array[j] < min) 
      min = array[j] 
      break 
    swap(array[i], array[j]) 

В этом случае вам не нужно два массива и вам не нужно удалять или вставлять элементы в массив либо.