Как вывести массив в обратном порядке без использования length

#java

Создаётся массив целых чисел. Нужно вывести массив в обратном порядке.
У меня получается при помощи .length. Есть ли способ сделать это без .length, используя
циклы for-each и арифметические действия?

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    System.out.println("введите количество элементов");
    int num = s.nextInt();
    int a[] = new int[num];
    System.out.println("введите элементы");
    for (int i = 0; i < num; i++) {
        a[i] = s.nextInt();
    }
    System.out.println("Элементы в обратном порядке");
    for (int i = a.length - 1; i >= 0; i--) {
        System.out.println(a[i]);
    }

    

Ответы

Ответ 1

Предположим, что у нас просто есть массив, созданный где-то и как-то (то есть доступа
к num и процессу его формирования мы не имеем). А также что нельзя проводить сортировку
массива (как оригинала, так и копии) и использовать другие структуры данных (списки,
стеки и т.д.). И, конечно, нельзя использовать .length у массива.

Первый вариант. Вычисление длины массива вручную:

int[] a = { 2, 3, 4 };
int length = 0;
for (int element : a)
{
    length++;
}
for (int i = length - 1; i >= 0; i--)
{
    System.out.println(a[i]);
}


Вместо for-each можно воспользоваться обычным циклом в связке с ArrayIndexOutOfBoundsException.

Второй вариант. Использование рекурсии для вывода на экран (по предложению @etki)
с ограничением рекурсии с помощью ArrayIndexOutOfBoundsException:

private static void print(int[] array, int index)
{
    try
    {
        int element = array[index];
        print(array, index + 1);
        System.out.println(element);
    }
    catch (ArrayIndexOutOfBoundsException ignored) { }
}

public static void main(String[] args)
{
    int[] a = { 2, 3, 4 };
    print(a, 0);
}


Ответ 2

1. Если цель вывести введенные данные в обратном порядке:

System.out.println("введите элементы");
for (int i = num; i > 0; i--) {
    a[i-1] = s.nextInt();
}


Соответственно вывод можно сделать просто:

System.out.println("Элементы в обратном порядке");
for (int i : a) {
    System.out.println(i);
}


2. Если массив трогать нельзя, а вывести надо в обратном порядке:

Код вывода после наполнения массива: 

String result = ""; 
for (int i : a) {
    result = i + "\r\n" + result;
}

System.out.println(result);


Ответ 3

Насколько я понял, мы заранее знаем кол-во элементов, так как получаем его с консоли.
Так что можно сделать так:

public static void main(String[] args) throws Exception {
    Scanner s = new Scanner(System.in);
    System.out.println("введите количество элементов");
    int num = s.nextInt();
    int a[] = new int[num];
    System.out.println("введите элементы");
    for (int i = 0; i < num; i++) {
        a[i] = s.nextInt();
    }
    System.out.println("Элементы в обратном порядке");
    for (int i = num - 1; i >= 0; i--) {
        System.out.println(a[i]);
    }
}


Ответ 4

Будем надеяться, вы просто проводите соревнование на самый неэффективный код 

private static void reversePrint(int[] array, int offset) {
    int index = -1;
    for (int entry : array) {
        if (++index == offset) {
            break;
        }
    }
    if (offset > index) {
        // значит, после полного прохода циклом до offset так и 
        // не удалось добраться - в массиве меньше элементов, и
        // выводить ничего не надо
        return;
    }
    reversePrint(array, offset + 1);
    System.out.println(array[offset]);
}


Из плюсов:


Не генерирует исключение
Тут совсем недалеко (но недостижимо из-за необходимости сохранения состояния) до
tail recursion, что - вот ведь хохма-то - дало бы возможность компилятору заоптимизировать
вызов до простого цикла
Кубок неэффективности явно ваш - рекурсия + n²


Ответ 5

Попробуйте так:

String[] arr = new String[5];
Arrays.sort(arr, Collections.reverseOrder()); // Инвертирует массив arr


В примере:

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);

    System.out.println("введите количество элементов");
    int num = s.nextInt();

    int a[] = new int[num];
    System.out.println("введите элементы");
    for (int i = 0; i < num; i++) {
        a[i] = s.nextInt();
    }

    System.out.println("Элементы в обратном порядке");

    Arrays.sort(a, Collections.reverseOrder()); // Инвертирует массив

    for (int i = a.length - 1; i >= 0; i--) {
        System.out.println(a[i]);
    }
}


Ответ 6

Можно воспользоваться стеком, тогда ваш код будет выглядеть так:

Scanner scanner = new Scanner(System.in);

System.out.println("введите количество элементов");
int num = scanner.nextInt();
System.out.println("введите элементы");

Stack stack = new Stack<>();
for (int i = 0; i < num; i++)
    stack.push(scanner.nextInt());

while (!stack.isEmpty())
    System.out.println(stack.pop());


Ответ 7

еще один вариант, но тут нужно указывать размер массива. После новый массив можно
использовать для своих нужд

    int size = 50;

    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int secArr[] = new int[size];

    int index = 1;
    for (int i : a) {
        secArr[size - ++index] = i;
    }

    for (int i = size - index; i < size; i++) {
        System.out.println(secArr[i]);
    }


http://ideone.com/pLvy6q