Hogyan lehet visszafordítani egy tömböt C ++, Python és JavaScript nyelven

A tömb az összefüggő memóriahelyeken tárolt elemek gyűjteménye. A tömb megfordítása az egyik leggyakoribb művelet, amelyet egy tömbön kell végrehajtani. Ebben a cikkben megtanulhatja, hogyan írhatja meg saját megvalósítását a tömb megfordításáról iteratív és rekurzív megközelítésekkel.

Iteratív megközelítés egy tömb megfordításához

Problémajelentés

Kapsz egy tömböt arr . Meg kell fordítania a tömb elemeit, majd ki kell nyomtatnia a fordított tömböt. Ezt a megoldást hurkok használatával kell megvalósítania.

1. példa : Legyen arr = [45, 12, 67, 63, 9, 23, 74]

Fordított arr = [74, 23, 9, 63, 67, 12, 45]

hogyan tudom megváltoztatni, hogy melyik gmail -fiók az alapértelmezett

Így a kimenet: 74 23 9 63 67 12 45.

2. példa : Legyen arr = [1, 2, 3, 4, 5, 6, 7, 8]

Fordított arr = [8, 7, 6, 5, 4, 3, 2, 1]

Így a kimenet: 8 7 6 5 4 3 2 1.

Megközelítés a tömb megfordításához hurkok segítségével

A tömb elemeit a ciklusok segítségével megfordíthatja az alábbi módszer szerint:

Inicializálja az „i” és „j” indexváltozókat úgy, hogy a tömb első (0) és utolsó (sizeOfArray - 1) indexére mutassanak.
Egy ciklusban cserélje ki az i indexben lévő elemet a j indexben lévő elemmel.
Növelje i értékét 1 -gyel, és csökkentse j értékét 1 -gyel.
Futtassa a ciklust, amíg i

C ++ program egy tömb megfordítására hurkok segítségével

Az alábbiakban bemutatjuk a C ++ programot a tömb megfordítására hurkok segítségével:

// C++ program to reverse the elements of an array using loops  
#include  
using namespace std;  
  
void reverseArr(int arr[], int size)  
{  
 for(int i=0, j=size-1; i {  
 swap(arr[i], arr[j]);  
 }  
}  
void printArrayElements(int arr[], int size)  
{  
 for(int i=0; i {  
 cout << arr[i] << ' ';  
 }  
 cout << endl;  
}  
// Driver Code  
int main()  
{  
 int arr[] = {45, 12, 67, 63, 9, 23, 74};  
 int size = sizeof(arr)/sizeof(arr[0]);  
 // Printing the original array  
 cout << 'Original Array: ' << endl;  
 printArrayElements(arr, size);  
 // Reversing the array  
 reverseArr(arr, size);  
 // Printing the reversed array  
 cout << 'Reversed array: ' << endl;  
 printArrayElements(arr, size);  
 return 0;  
}

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

Összefüggő: Hogyan lehet visszafordítani egy karakterláncot C ++, Python és JavaScript nyelven

Python program egy tömb megfordítására hurkok segítségével

Az alábbiakban a Python program állítja vissza a tömböt ciklusok használatával:

# Python program to reverse the elements of a list using loops  
def reverseList(arr, size):  
 i = 0  
 j = size-1  
 while i arr[i], arr[j] = arr[j], arr[i]  
 i = i + 1  
 j = j - 1  
def printListElements(arr, size):  
 for i in range(size):  
 print(arr[i], end=' ')  
 print()  
# Driver Code  
arr = [45, 12, 67, 63, 9, 23, 74]  
size = len(arr)  
# Printing the original array  
print('Original Array:')  
printListElements(arr, size)  
# Reversing the array  
reverseList(arr, size)  
# Printing the reversed array  
print('Reversed Array:')  
printListElements(arr, size)

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

JavaScript program egy tömb megfordítására hurkok segítségével

Az alábbiakban bemutatjuk a JavaScript programot a tömb megfordítására hurkok segítségével:

Összefüggő: Bevezetés az egyesítési rendezési algoritmusba

// JavaScript program to reverse the elements of an array using loops  
function reverseArr(arr, size) {  
 for(let i=0, j=size-1; i<(size)/2; i++, j--) {  
 [arr[i], arr[j]] = [arr[j], arr[i]];  
 }  
}  
function printArrayElements(arr, size) {  
 for(let i=0; i document.write(arr[i] + ' ');  
 }  
 document.write('  
');  
}  
// Driver Code  
var arr = [45, 12, 67, 63, 9, 23, 74];  
var size = arr.length;  
// Printing the original array  
document.write('Original Array: ' + '  
');  
printArrayElements(arr, size);  
// Reversing the array  
reverseArr(arr, size);  
// Printing the reversed array  
document.write('Reversed Array: ' + '  
');  
printArrayElements(arr, size);

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

Rekurzív megközelítés egy tömb megfordításához

Problémajelentés

Kapsz egy tömböt arr . Meg kell fordítania a tömb elemeit, majd ki kell nyomtatnia a fordított tömböt. Ezt a megoldást rekurzióval kell megvalósítania.

1. példa : Legyen arr = [45, 12, 67, 63, 9, 23, 74]

Fordított arr = [74, 23, 9, 63, 67, 12, 45]

Így a kimenet 74 23 9 63 67 12 45.

2. példa : Legyen arr = [1, 2, 3, 4, 5, 6, 7, 8]

Fordított arr = [8, 7, 6, 5, 4, 3, 2, 1]

Így a kimenet 8 7 6 5 4 3 2 1.

Egy tömb megfordításának megközelítése rekurzió segítségével

A tömb elemeit rekurzió segítségével megfordíthatja az alábbi módszer szerint:

Inicializálja az indexváltozókat Rajt és vége úgy, hogy a tömb első (0) és utolsó (sizeOfArray - 1) indexére mutatnak.
Cserélje ki az elemet az indexen Rajt elemmel az indexnél vége .
Rekurzív módon hívja meg a fordított funkciót. A fordított függvény paramétereiben növelje a Rajt 1 -gyel, és csökkenti az értékét vége 1 által.
Állítsa le a rekurziót, amikor a Rajt változó nagyobb vagy egyenlő a vége változó.

C ++ program tömb megfordítására rekurzió segítségével

Az alábbiakban bemutatjuk a C ++ programot egy tömb megfordítására rekurzió segítségével:

// C++ program to reverse an array using recursion  
#include  
using namespace std;  
void reverseArr(int arr[], int start, int end)  
{  
 if (start >= end)  
 {  
 return;  
 }  
swap(arr[start], arr[end]);  
 reverseArr(arr, start+1, end-1);  
}  
void printArrayElements(int arr[], int size)  
{  
 for(int i=0; i {  
 cout << arr[i] << ' ';  
 }  
 cout << endl;  
}  
// Driver Code  
int main()  
{  
 int arr[] = {45, 12, 67, 63, 9, 23, 74};  
 int size = sizeof(arr)/sizeof(arr[0]);  
 // Printing the original array  
 cout << 'Original Array: ' << endl;  
 printArrayElements(arr, size);  
 // Reversing the array  
 reverseArr(arr, 0, size-1);  
 // Printing the reversed array  
 cout << 'Reversed array: ' << endl;  
 printArrayElements(arr, size);  
 return 0;  
}

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

Python program tömb megfordítására rekurzió segítségével

Az alábbiakban bemutatjuk a Python programot egy tömb visszafordításához rekurzió segítségével:

hogyan lehet szinkronizálni egy xbox 1 vezérlőt

Kapcsolódó: Dinamikus programozás: példák, gyakori problémák és megoldások

# Python program to reverse an array using recursion  
def reverseList(arr, start, end):  
 if start >= end:  
 return  
 arr[start], arr[end] = arr[end], arr[start]  
 reverseList(arr, start+1, end-1)  
def printListElements(arr, size):  
 for i in range(size):  
 print(arr[i], end=' ')  
 print()  
# Driver Code  
arr = [45, 12, 67, 63, 9, 23, 74]  
size = len(arr)  
# Printing the original array  
print('Original Array:')  
printListElements(arr, size)  
# Reversing the array  
reverseList(arr, 0, size-1)  
# Printing the reversed array  
print('Reversed Array:')  
printListElements(arr, size)

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

JavaScript program tömb megfordítására rekurzió segítségével

Az alábbiakban bemutatjuk a JavaScript programot egy tömb visszafordításához rekurzió segítségével:

Kapcsolódó: Hogyan találjuk meg a természetes számok összegét rekurzió segítségével?

// JavaScript program to reverse an array using recursion  
function reverseArr(arr, start, end)  
{  
 if (start >= end)  
 {  
 return;  
 }  
 [arr[start], arr[end]] = [arr[end], arr[start]];  
 reverseArr(arr, start+1, end-1);  
}  
function printArrayElements(arr, size)  
{  
 for(let i=0; i {  
 document.write(arr[i] + ' ');  
 }  
 document.write('  
');  
}  
// Driver Code  
var arr = [45, 12, 67, 63, 9, 23, 74];  
let size = arr.length;  
// Printing the original array  
document.write('Original Array: ' + '  
');  
printArrayElements(arr, size);  
// Reversing the array  
reverseArr(arr, 0, size-1);  
// Printing the reversed array  
document.write('Reversed Array: ' + '  
');  
printArrayElements(arr, size);

Kimenet:

Original Array:  
45 12 67 63 9 23 74  
Reversed array:  
74 23 9 63 67 12 45

Használja a rekurziót a problémák megoldásához

A rekurzív függvény egy önmagát hívó függvény. Rekurzió esetén a problémát úgy oldják meg, hogy a problémákat önmaguk kisebb, egyszerűbb verzióira bontják.

A rekurziónak számos előnye van: a rekurzív kód rövidebb, mint egy iteratív kód, fel lehet használni a természetesen rekurzív problémák megoldására, használható infix, prefix, postfix értékelésekben, a rekurzió csökkenti az íráshoz szükséges időt és hibakeresési kód stb.

A rekurzió az interjúztatók kedvenc témája a technikai interjúk során. Tudnia kell a rekurzióról és annak használatáról, miközben kódot ír, hogy a lehető leghatékonyabb programozó legyen.

Részvény Részvény Csipog Email Mi a rekurzió és hogyan kell használni?

Ismerje meg a rekurzió alapjait, a programozók alapvető, de kissé elgondolkodtató eszközét.

Olvassa tovább Kapcsolódó témák

Programozás
JavaScript
Piton
Kódolási oktatóanyagok

A szerzőről Yuvraj Chandra(60 cikk megjelent)

Yuvraj egy számítástechnikai egyetemi hallgató a Delhi Egyetemen, Indiában. Szenvedélyesen foglalkozik a Full Stack webfejlesztéssel. Amikor nem ír, a különböző technológiák mélységét kutatja.

Bővebben: Yuvraj Chandra

Iratkozzon fel hírlevelünkre

Csatlakozz hírlevelünkhöz, ahol technikai tippeket, véleményeket, ingyenes e -könyveket és exkluzív ajánlatokat találsz!

Feliratkozáshoz kattintson ide