Обръщане на масив в Java

Масивите се използват често в codeирането и са начин за съхраняване на множество стойности от един и същи тип в една променлива. Може да има много причини, поради които codeерът може да иска да обърне масив. Може да се наложи да обърнете масив, например, когато логиката на даден проблем трябва да започне с последния елемент. В този случай най-добрата практика е да направите обръщането и след това да използвате обърнатия масив, където е необходимо в codeа. Нещо повече, обръщането на масив е много популярна задача в интервютата на Java Juniors.

Как да обърнете масив

Има много начини за обръщане на масив и тук разглеждаме 5. За Вариант 1 масивът се обръща с помощта на допълнителен масив, попълнен във възходящ ред от края на оригиналния масив (низходящ), във Вариант 2 обръщане на място се извършва, когато елементите на масива в началото и края се разменят, във Вариант 3 методът reverse() от рамката на колекциите се използва за извършване на обръщането, във Вариант 4, List.add() и List.remove() се използват и накрая, във Вариант 5 се използва рекурсия.

Опция 1: Обръщане на масив с помощта на допълнителен масив

Нека напишем прост метод за обръщане на масив с помощта на допълнителен масив . Тази опция използва допълнителен масив, който се запълва, започвайки с последния елемент на оригиналния масив в низходящ ред, т.е. първият елемент е същият като последния елемент в оригиналния масив, вторият е същият като втория от последния и така докато не се запълни допълнителният масив.

import java.util.Arrays;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {7, 8, 9, 10, 11};
       System.out.println("Array : " + Arrays.toString(array)); // print array

       // Call function to get reversed array
       int[] reversedArray = reverse(array);
       System.out.println("Reversed array : " + Arrays.toString(reversedArray)); // print reversed array
   }

   // Method returns a new reversed array, based on the array which was passed to it.
   static int[] reverse(int[] array) {
       int[] newArray = new int[array.length];

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

       return newArray;
   }
}

В този пример написахме метод, който обръща масив и връща нов обърнат масив, базиран на масива, който му е предаден. масивът се декларира в main и след това се извиква метод, reverse . Аргументът на метода е масивът. В обратния метод се създава нов масив, newArray , който е със същия размер като array , само че е напълно празен. Цикъл for се използва за попълване на newArray и работи по цялата дължина на масива. Това се прави, като се започне с първия елемент на масива и се присвои на последния елемент на newArray, след което вземаме втория елемент от нашия масив и го присвояваме на предпоследния елемент на newArray и т.н.; newArray се попълва наобратно. Когато цикълът for е завършен, newArray е напълно пълен и е точно обратното на масива .

Опция 2: Отпечатайте елементите на масив в обратен ред

За тази опция за обръщане на масив не е необходимо да се използва допълнителен масив и той не се преобразува в списък с масиви. Вместо това елементите на масива се поставят в обратен ред на място . Това означава, че те всъщност са разменени. Първият елемент се разменя с последния елемент, вторият елемент се разменя с втория от последния и т.н. Използва се for цикъл и когато това приключи, масивът ще бъде обърнат. Кодът изглежда така:

import java.util.Arrays;
/*
reversing an array in-place
*/
public class ReverseArrayDemo {

   public static void main(String[] args) {
       int[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       arrayReverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//arrayReverse is a method that reverses array in-place
   static void arrayReverse(int[] array) {
       for (int i = 0; i < array.length / 2; i++) {
           int temp = array[i];
           array[i] = array[array.length - i - 1];
           array[array.length - i - 1] = temp;
       }
   }
}

Оригиналният масив се отпечатва като String с помощта на Arrays.toString(array) и след това нашият масив се предава като аргумент в reverse . При обратния метод в цикъла for се създава и използва променлива temp. В цикъла for обратният ред се постига в три стъпки:

1. присвояване на първия елемент на temp
2. присвояване на последния елемент на първия елемент
3. присвояване на temp на последния елемент

След това това се извършва отново този път за втория елемент и втория от последния елемент и т.н. Това се прави за последователни елементи на масива, но цикълът итерира само до половината от размера на масива. По същество елементите в противоположните краища на масива се разменят. Този метод ще работи два пъти по-бързо от метод, използващ for цикъл, преминаващ от 0 до size. В резултат на това се постига обратен ред на масива и ни се показва How да отпечатаме масив в обратен ред и стойностите се отпечатват:

Опция 3: Използване на Collections.reverse()

В Java обратният метод, който е част от съществуващата рамка на колекциите, може да се използва за обръщане на масив. Нека го използваме, за да направим обръщането.

import java.util.Arrays;
import java.util.Collections;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = {1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }
//method that reverses an array
   static void reverse(Integer[] array) {
       Collections.reverse(Arrays.asList(array));
   }
}

В main масивът се създава и попълва като масив с цели числа с 5 числа. След това се отпечатва като списък с помощта на Arrays.asList(array) и след това функцията, reverse , се извиква и масивът се предава като аргумент в тази функция. В reverse се използва Collections.reverse и това се използва в списъка с масиви Arrays.asList(array) , а не самия масив. След това в следващата стъпка ни се показва How да отпечатаме масив в обратен ред с помощта на System.out.println и този път всеки елемент се отпечатва на същия ред:

Опция 4: Обръщане на масив с помощта на List.add() и List.remove()

В тази нова опция List.add() и List.remove() се използват за извършване на обръщането. Начинът, по който това работи, е, че масивът се преобразува в списък и последният елемент от списъка се премахва и се поставя в началото на списъка. След като целият списък е повторен, новият списък е обратен на оригинала. В метода main() се създава масив, състоящ се от 5 числа. След това първоначалното състояние на масива се извежда на конзолата. След това този масив се поставя като аргумент на метода, reverse() . Този метод основно работи чрез премахване на последния елемент и вмъкването му в предната част на масива. Накрая, новото (обърнато) състояние на масива се извежда на конзолата. В обратната посока ()метод, масивът се записва в списък чрез Arrays.asList(array) , за да се активират методите add() и remove() за извършване на обръщането. Този метод основно работи чрез премахване на последния елемент и вмъкването му в предната част на масива. Стъпките, които reverse() използва, са Howто следва. Той използва for цикъл, за да извърши обръщането на елементите на списъка. Той прави това чрез инициализиране на променлива i . Първоначално i е зададен на 0. Когато i = 0 , елементът в list.size() - 1 в списъка се премахва и това винаги ще бъде последният елемент, тъй като i < list.size() - 1. Тъй като методът remove() връща елемента, който е премахнал, този елемент сега се добавя към списъка при индекс i = 0 , т.е. вмъква се в началото. След това останалата част от списъка се измества надясно, но новият списък все още има същия брой елементи, т.е. размер . Продължавайки изпълнението на цикъла for със следващата стойност на i , i = 1 , се извършва същият набор от стъпки, така че последният елемент се премахва и се поставя в nums при i = 1 и списъкът се измества надясно. Това продължава, докато последната нарастваща стойност на i и всички елементи в списъка не бъдат променени. Във втория заloop елемент от списъка с индекс i е зададен на елемента на масива с индекс i , където i е от 0 до list.size() - 1 . За да обобщим, използваните стъпки са: Стъпки:

1. i = 0
2. премахване на елемент в list.size() - 1
3. вмъкнете елемент, който беше в list.size() - 1 , при i = 0
4. увеличение i
5. повторете стъпки от 2 до 4 (с нови стойности за i в стъпка 3), докато се използва последната нарастваща стойност на i

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       reverse(array);
       System.out.println("Array after reverse : " + Arrays.toString(array));
   }

   static void reverse(Integer[] array) {
       List list = new ArrayList<>(Arrays.asList(array));

       for (int i = 0; i < list.size() - 1; i++) {
           list.add(i, list.remove(list.size() - 1));
       }

       for (int i = 0; i < list.size(); i++) {
           array[i] = list.get(i);
       }
   }
}

Този code дава резултата:

Опция 5: Обръщане на масив чрез рекурсия

Методът на рекурсия се използва широко в codeирането и може да се използва за създаване на ефективен метод за обръщане на масив. В тази опция масивът се преобразува в списък и след това codeът отива в метода reverse() всеки път, когато премахва последния елемент в края на списъка и списъкът има премахнатите стойности, добавени към него в обратен ред. Както и в предишните методи, се създава масив, състоящ се от 5 числа. След това се предава като аргумент във функцията, reverse() . В reverse() първото нещо, което се прави, е да превърнете масива в списък и да проверите размера на списъка. Ако има само един елемент or е нула, тогава методът завършва и се връща. Ако не, първият елемент се премахва, но се копира в Integer, стойност . След това методът reverse() се извиква отново и рекурсията започва отново. Когато функцията е въведена, се извършват същите стъпки, проверка на размера, при която, ако списъкът е по-голям от 1, следващата стъпка ще бъде премахването на първия елемент и след това повторното извършване на рекурсията. Когато размерът на списъка е 1, reverse() се връща там, откъдето е извикан, и след това към списъка се добавя всяка стойност , за да се изгради в точно обратното на оригиналния списък.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ReverseArrayDemo {

   public static void main(String[] args) {
       Integer[] array = new Integer[]{1, 4, 9, 16, 25};
       System.out.println("Array before reverse : " + Arrays.toString(array));

       List list = new ArrayList<>(Arrays.asList(array));
       reverse(list);
       System.out.println("Array after reverse : " + Arrays.toString(list.toArray()));
   }

   public static void reverse(List list) {
       if (list== null || list.size() <= 1) {
           return;
       }

       Integer value = list.remove(0);

       reverse(list);

       list.add(value);
   }
}

Резултатът е:

Заключение

Така че тук разгледахме 5 различни начина за обръщане на масив. Вариант 3, който използва рамката на Collections, вероятно е най-добрият метод за използване, тъй като Collections.reverse е вече съществуваща, изпитана и тествана Java функция. Разбира се, другите опции могат да се използват, особено докато учите, но като цяло стандартните методи, ако съществуват, са най-добрите, тъй като обикновено са силно оптимизирани и тествани. Можете обаче сами да създадете такива методи, тъй като това е добро упражнение за codeиране и ще ви помогне да успеете в интервюто си за Java Junior.