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

#java #массивы #сортировка

Java. Прошу помощи. Необходимо массив из чисел int отсортировать в возрастающем порядке
с помощью определенного способа - первым шагом сравнить и обменять элементы i и i+1,
где i - четное число. Вторым шагом - где i - нечетное число. Повторять пока массив
не будет отсортирован. Сделать надо с помощью дополнительного метода.
Пример:


Как ни делал - выдает ошибку array out of bounds.

    public static void firstMethod(int[] A) {
    int z, j;
    for (j=0; j

Ответы
Ответ 1

То, что вы описали довольно сильно похоже на сортировку пузырьком, но несколько отличается
(в сортировке пузырьком предполагается проход элементов подряд, следствием чего является
получение за каждую итерацию максимального/минимального элемента из просматриваемых,
здесь же несколько другая формулировка, а в итоге алгоритм совсем другой). 
P.S. Уточните, правильно ли вы поняли формулировку, если да, то реализация sort()
вам подойдет, но если это, все-таки, пузырек, то воспользуейтесь методом bubbleSort().

public class Solution
{
    public static void main(String[] args)
    {
        int[] massive = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

        System.out.print("Начальное состояние массива:        ");
        showout(massive);

        sort(massive);

        System.out.print("Состояние массива после сортировки: ");
        showout(massive);
    }

    /** реализует ту сортировку, которую вы описали */
    private static void sort(int[] massive)
    {
        boolean isAlreadySorted;
        do
        {
            isAlreadySorted = sort(massive, 0) & sort(massive, 1);
        } while (!isAlreadySorted);
    }

    /** при необходимости меняет местами соседние элементы массива massive начиная
с позиции startIndex и далее через одну */
    private static boolean sort(int[] massive, int startIndex)
    {
        boolean isAlreadySorted = true;
        for (int index = startIndex; index < massive.length - 1; index += 2)
        {
            if (massive[index] > massive[index + 1])
            {
                isAlreadySorted = false;
                swap(massive, index, index + 1);
            }
        }
        return isAlreadySorted;
    }

    /** меняет местами элементы массива massive с индексами leftIndex и rightIndex */
    private static void swap(int[] massive, int leftIndex, int rightIndex)
    {
        massive[leftIndex] ^= massive[rightIndex];
        massive[rightIndex] ^= massive[leftIndex];
        massive[leftIndex] ^= massive[rightIndex];
    }

    /** выводит элементы массива на экран */
    private static void showout(int[] massive)
    {
        for (int index = 0; index < massive.length - 1; ++index)
        {
            System.out.print(massive[index] + ", ");
        }
        System.out.println(massive[massive.length - 1]);
    }

    /** обычная сортировка пузырьком */
    private static void bubbleSort(int[] massive)
    {
        boolean isAlreadySorted = false;
        for (int i = 0; i < massive.length - 1 && !isAlreadySorted; i++)
        {
            isAlreadySorted = true;
            for (int j = 0; j < massive.length - i - 1; j++)
            {
                if (massive[j] > massive[j + 1])
                {
                    swap(massive, j, j + 1);
                    isAlreadySorted = false;
                }
            }
        }
    }
}


Ответ 2

Обычная сортировка пузырьком                                                    
                                                                              

boolean changes;
do {
    changes = false;
    for (int i = 0; i < array.length - 1; i++) {
        if (array[i] < array[i + 1]) {
            int _current = array[i];
            array[i] = array[i + 1];
            array[i + 1] = _current;
            changes = true;
        }
    }

}
while (changes);


Ответ 3

Я бы сделал как-то так:

public static void firstMethod(int[] a) {
    boolean isSorted = false;

    while (!isSorted) {
        isSorted = true;

        for (int i = 0; i < a.length - 1; i += 2) {
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
                isSorted = false;
            }
        }
        for (int i = 1; i < a.length - 1; i += 2) {
            if (a[i] > a[i + 1]) {
                int temp = a[i];
                a[i] = a[i + 1];
                a[i + 1] = temp;
                isSorted = false;
            }
        }
    }
}


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