Сортировка массива

1

Это текстовый файл:

1,2,8,4,5,6,7,7,

3,4,5,6,7,8,

5,6,7,8,9,9,

1,2,3,4,5,8,9,0

После игнорирования 1-й колонки:

2,8,4,5,6,7,7,

4,5,6,7,8,

6,7,8,9,9,

2,3,4,5,8,9,0

Я хочу сортировать массив в порядке убывания, но я не могу заставить его работать. Это код, который я сделал до сих пор:

Scanner scanner = new Scanner(new File("test.txt"));

int row = 0;
int col = 0;

while (scanner.hasNextLine())
{
    String currentline = scanner.nextLine();

    row++;

    String[] items = currentline.split(",");
    int[] intitems = new int[items.length];

    for (int i = 1; i < items.length; i++)
    {
        intitems[i] = Integer.parseInt(items[i]);

        System.out.print(intitems[i] + " ");

        int temp = 0;
        for (int j = 2; j < (items.length - i); j++)
        {
            temp = intitems[j - 1];
            intitems[j - 1] = intitems[j];
            intitems[j] = temp;
        }
        col = i;
    }

    col++;
    System.out.println();
    System.out.println("After sort: " + intitems);

    System.out.println();
}

System.out.println("Row: " +row);
  • 0
    Мой плохой, я случайно пометил javascript. Sry
  • 0
    Имеет ли значение алгоритм сортировки?
Показать ещё 1 комментарий
Теги:
netbeans
sorting
netbeans-7

5 ответов

1
Лучший ответ
private static void sortInDescending(int[] arrayObj) 
    {           
        int n = arrayObj.length;
        int temp = 0;

        for(int i=0; i < n; i++)
        {
            for(int j=1; j < (n-i); j++)
            {                                   
                if(arrayObj[j-1] < arrayObj[j])
                {
                    temp = arrayObj[j-1];
                    arrayObj[j-1] = arrayObj[j];
                    arrayObj[j] = temp;
                }                         
            }
        }   
    }

Метод вызова

 sortInDescending(arrayinput);
4

Не нужно усложнять вещи:

for (int i = 1; i < items.length; i++) {
  intitems[i - 1] = Integer.parseInt(items[i]);
}

Arrays.sort(intitems); // Ascending
Arrays.sort(intitems, Collections.reverseOrder()); // Descending

Но если вы действительно хотите использовать цикл для сортировки массива (bubblesort), вам нужно сравнить элементы, которые вы переключаете:

for (int i = 0; i < intitems.length - 1; i++) {
  for(int j = i + 1; j < intitems.length; j++) {
    if (intitems[i] > intitems[j]) {
      int temp = intitems[j];
      intitems[j] = intitems[i];
      intitems[i] = temp;
    }
  }
}

Если вы хотите, чтобы он отсортировался в порядке убывания, просто измените greater than (>) сравнение на lesser than (<) сравнение:

    if (intitems[i] < intitems[j]) {
  • 0
    Это совсем не помогает, он явно хочет освоить алгоритм сортировки, а не использовать встроенную функцию, которую может использовать любой тупой.
  • 0
    Пожалуйста, укажите, какой алгоритм сортировки вы используете: P
Показать ещё 2 комментария
1

Там вы идете:

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;

 public class SortTXT {

static File fout;

public static void main(String[] args) {

    fout = new File("text.txt");
    if (!fout.isFile()) 
    {
        System.out.println("text.txt - Parameter is not an existing file");
    }
    else
    {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new InputStreamReader(new FileInputStream(fout)));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        String line = null;
        try {
            while ((line = br.readLine()) != null) {
                if (line.length()>2)
                {
                    line.trim();
                    // crete an array from the line - seperate by ","
                    List<String> list = new ArrayList<String>(Arrays.asList(line.split(",")));
                    // remove the 1st number
                    list.remove(0);
                    //sorting the list
                    Collections.sort(list);
                    System.out.println();
                    System.out.println("After sort: ");

                    // print out the sorted array
                    for(String temp: list){
                        System.out.print("," + temp);
                }
            }
            }
        } catch (IOException e) {
        }

        try {
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

}

Надеюсь это поможет :)

Дэйв.

1

Другие ответы содержат алгоритм сортировки пузырьков, где один элемент сравнивается с его преемником. Если условие сортировки совпадает, то они меняются местами. Немного более быстрое решение - это сортировка вставки: по сути, она находит максимальное (минимальное) значение массива и ставит его на передний план. Там реализация может выглядеть так:

static int[] array = {2,8,4,5,6,7,7,};


public static void insertionSort(final int[] array) {       

    for(int i = 0; i < array.length; i++){
        int maxValueIndex = findMaxValue(array, i);

        int temp = array[i];
        array[i] = array[maxValueIndex];
        array[maxValueIndex]=temp;
    }
}

private static int findMaxValue(final int[] array, int index) {

    int value = Integer.MIN_VALUE;

    for (int i = index; i < array.length; i++) {

        if (array[i] > value) {
            value = array[i];
            index = i;
        }
    }
    return index;
}

public static void main(final String[] args){
    insertionSort(array);
    System.out.println(Arrays.toString(array));
}
1

Вы можете использовать Arrays.sort() с помощью специализированного компаратора, чтобы уменьшить его.

    String[] items = currentLine.split(",");
    Integer[] intItems = new Integer[items.length];

    for(int i=0; i<intItems.length; ++i) {
        intItems[i] = Integer.parseInt(items[i]);
    }

    Comparator<Integer> comparator = new Comparator<Integer>() {
        @Override
        public int compare(Integer left, Integer right) {
            return -Integer.compare(left, right);
        }
    };

    Arrays.sort(intItems, comparator);

    System.out.println(Arrays.toString(intItems));
}

Или вы можете отсортировать массив в порядке возрастания и изменить массив.

    Arrays.sort(intItems);

    Integer[] descending = new Integer[intItems.length];

    int length = descending.length;
    for(int i=0; i<length; ++i) {
        descending[i] = intItems[length - 1 - i];
    }

    System.out.println(Arrays.toString(descending));

Ещё вопросы

Сообщество Overcoder
Наверх
Меню