Java >> Java tutorial >  >> Java

Vend et array i Java

Vend et array i Java | Array-programmer i Java – 16 | I det tidligere Java-program udviklede vi programmer til at finde det næststørste tal i arrayet og sortere et array i Java. I dette indlæg vil vi se, hvordan man vender et array i Java. Vi vil diskutere forskellige teknikker som f.eks. hvordan man vender et array i Java ved hjælp af for loop, uden at bruge et andet array i java, eller brug af rekursion.

Eksempel:-

Originalt array:- { 10, 20, 30, 40, 50
Omvendt af array:- { 50, 40, 30, 20, 10 }

Vend et array ved hjælp af et andet array

Procedure for at vende et array ved hjælp af et andet array og loop ,

a) Tag et array, antag realArr
b) Find længden af ​​det originale array. Se:- Sådan finder du længden af ​​et array i Java
c) Erklær et andet array med samme længde, reverseArr
d) Fra realArr , vælg fra den sidste og indsæt for at reverseArr fra starten
e) Gentag (d) indtil slutningen af ​​realArr

Et eksempel på denne procedure,

int realArr[] = { 10, 20, 30 }; // original array
int reverseArr[3]; // new array

Derefter
reverseArr[0] = realArr[2];
reverseArr[1] = realArr[1];
reverseArr[2] = realArr[0];

Til sidst, det modsatte af arrayet:-
reverseArr[] = { 30, 20, 10 };

Lad os nu Java-programmere til at vende et array ved hjælp af while-løkke og et andet array. I stedet for while-løkke kan du bruge en anden løkke, f.eks. for løkke, eller do-while-løkke.

import java.util.Arrays;
import java.util.Scanner;

public class ArrayTest {
  
  // method to reverse an array using another array
  public static int[] reverse(int[] realArr) {
    // declare variables
    int size = 0;
    int reverseArr[] = null;
    
    // find length of the given array
    size = realArr.length;
    
    // temporary array of the same size
    reverseArr = new int[size];
    
    // find reverse and store to temporary array
    // initialize iterator variables
    int i = 0;
    int j = size-1;
    
    while(i < size) {
      // assign element
      reverseArr[i] = realArr[j];
      
      // update iterator variables
      i++;
      j--;
    }
        
    // return result 
    return reverseArr;
  }

  public static void main(String[] args) {
    // declare variables
    Scanner scan = null;
    int size = 0;
    int numbers[] = null;
    int rev[] = null;
    
    // create Scanner class object to take input
    scan = new Scanner(System.in);
    
    // read array size
    System.out.print("Enter array size: ");
    size = scan.nextInt();
    
    // assign length to array
    numbers = new int[size];
    
    // read array elements 
    System.out.println("Enter array elements: ");
    for(int i=0; i<size; i++) {
      numbers[i] = scan.nextInt();
    }
    
    // find reverse and store to rev
    rev = reverse(numbers);
    
    // display reverse of the array
    System.out.println("Reverse = " + Arrays.toString(rev));
    
    // close Scanner 
    scan.close();
  }
}

Output:-

Indtast matrixstørrelse:5
Indtast matrixelementer:
10 20 30 40 50
Omvendt =[50, 40, 30, 20, 10]

Vend et array i Java ved hjælp af For Loop

I ovenstående program havde vi brugt while-løkken. Lad os nu se den samme metode ved at bruge for-løkken.

Mens loop er en pre-test loop, hvor udtrykket evalueres, udføres kun sætninger. Den bruger et testudtryk til at kontrollere løkken. Før hver iteration af løkken evalueres testudtrykket. For-løkken er også en præ-test-løkke, hvor først og fremmest initialiseringsudtryk evalueres, derefter kontrolleres betingelsen, og hvis betingelsen er sand, udføres kun sætningerne fra for-løkken.

// method to reverse an array using for loop
public static int[] reverse(int[] realArr) {
   // declare variables
   int size = 0;
   int reverseArr[] = null;
    
   // find length of the given array
   size = realArr.length;
    
   // temporary array of the same size
   reverseArr = new int[size];
    
   // find reverse and store to temporary array
   for(int i=0, j=size-1; i<size; i++, j--) {
      // assign element
      reverseArr[i] = realArr[j];
   }
        
   // return result 
   return reverseArr;
}

I stedet for den tidligere metode, som brugte en while-løkke, skal du bruge denne metode ovenfor. Fremgangsmåden for begge metoder er nøjagtig den samme, den eneste forskel er brugen af ​​en løkke. For-løkken reducerede kodelinjerne sammenlignet med while-løkken.

Vend et array i Java ved hjælp af While Loop

// find reverse and store to temporary array
// initialize iterator variables
int i = 0;
int j = size-1;
    
while(i < size) {
   // assign element
   reverseArr[i] = realArr[j];
      
   // update iterator variables
   i++; // increase i 
   j--; // decrease j
}

Brug for loop,

// find reverse and store to temporary array
for(int i=0, j=size-1; i<size; i++, j--) {
   // assign element
   reverseArr[i] = realArr[j];
}

Vend et array uden at bruge et andet array i Java

Det er også muligt ikke at bruge et andet array. Kun ved at bruge det originale array kan vi vende arrayet. På denne måde skal vi bytte de tilsvarende elementer fra første og sidste.

Fremgangsmåde for at vende et array ved hjælp af det samme array,
a) Tag et array, antag arr
b) Find længden af ​​arrayet
c) Vælg det første og sidste element i arrayet og skift dem
d) Gentag denne proces indtil længde/2

Hvis længden af ​​arrayet er lige, skal alle elementer i arrayet byttes med et relativt element, men hvis længden af ​​arrayet er ulige, vil elementet i midterpositionen forblive det samme.

Eksempel

Eksempel ved brug af en matrix med lige længde,
arr[] = {10,20,30,40}; // original array
Skift nu arr[0] og arr[3] og derefter
arr[] = {40,20,30,10};
Igen, skift arr[1] og arr[2] og derefter
arr[] = {40,30,20,10; // final result

Eksempel ved brug af en matrix med ulige længde,
arr[] = {10,20,30,40,50}; // original array
Skift nu arr[0] og arr[4] og derefter
arr[] = {50,20,30,40,10};
Igen, skift arr[1] og arr[2] og derefter
arr[] = {50,40,30,20,10}; // final result
Ingen grund til at gøre noget med elementet i midterpositionen.

Lad os nu se Java-metoden til at finde bagsiden af ​​et array uden at bruge et andet array.

Vend et array i Java ved hjælp af While Loop

Java-metode til at vende et array ved at bruge while-løkke og uden at bruge et andet array.

// method to reverse an array without another array
public static int[] reverse(int[] arr) {
    
   // find size
   int size = arr.length;
    
   // variables
   int i = 0;
   int j = size - 1;

   // while loop
   while (i <= size / 2) {
      
     // swap elements
     int temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;

     // update i & j
     i++; // increase i
     j--; // decrease j
   }
    
   // return result
   return arr;
}

Brug for loop

Java-metode til at vende et array med for loop og uden at bruge et andet array.

// method to reverse an array without another array
public static int[] reverse(int[] arr) {

   // find size
   int size = arr.length;

   // for loop
   for(int i=0, j=size-1; i<(size/2); i++, j--) {

      // swap
      int temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
   } 

   // return result 
   return arr;
}

Vend et array i Java ved hjælp af rekursion

Vi kan vende et array ved hjælp af rekursionsteknikken. En metode, der indeholder et kald til sig selv, kaldes den rekursive metode. En teknik til at definere den rekursive metode kaldes rekursion. Den rekursive metode giver os mulighed for at opdele det komplekse problem i identiske enkelte simple tilfælde, der nemt kan håndteres. Dette er også en velkendt computerprogrammeringsteknik:del og hersk.

// method to reverse an array
public static int[] reverse(int[] arr) {
   reverseArr(arr, 0, arr.length - 1);
   return arr;
}

// recursive method
public static void reverseArr(int[] x, int i, int j) {

   // swap
   if (i < j) {
     int tmp = x[i];
     x[i] = x[j];
     x[j] = tmp;

     // recursive call
     reverseArr(x, ++i, --j);
   }
}

Ovenstående metode kræver ikke et andet midlertidigt array for at gemme værdierne. Reverse() er ikke en rekursiv metode, den kalder internt reverseArr(), som er en rekursiv metode, og kalder internt sig selv.

Tidskompleksiteten af ​​alle metoderne givet i dette indlæg er:- O(N) .


Java tag