数组是存储在连续内存位置的项目的集合。数组的反转是对数组执行的最常见的操作之一。在本文中,您将学习如何使用迭代和递归方法编写自己的数组反转实现。

反转数组的迭代方法

问题陈述

你得到一个数组arr。您需要反转数组的元素,然后打印反转的数组。您需要使用循环来实现此解决方案。

示例 1:设 arr = [12,30,45,6,99,88,7]

反转 arr = [7,88,99,6,45,30,12]

因此输出为:7 88 99 6 45 30 12。

示例 2:设 arr = [1, 2, 3, 4, 5, 6, 7, 8]

反转 arr = [8, 7, 6, 5, 4, 3, 2, 1]

因此输出为:8 7 6 5 4 3 2 1。

使用循环反转数组的方法

您可以按照以下方法使用循环反转数组的元素:

  1. 初始化索引变量“i”和“j”,使它们分别指向数组的第一个 (0) 和最后一个 (sizeOfArray – 1) 索引。
  2. 在循环中,将索引 i 处的元素与索引 j 处的元素交换。
  3. 将 i 的值加 1,将 j 的值减 1。
  4. 运行循环直到 i < sizeOfArray/2。

使用循环反转数组的 C++ 程序

下面是使用循环反转数组的 C++ 程序:

// C++程序,使用循环来反转数组中的元素
#include <iostream>
using namespace std;

void reverseArr(int arr[], int size)
{
 for(int i=0, j=size-1; i<size/2; i++, j--)
 {
 swap(arr[i], arr[j]);
 }
}
void printArrayElements(int arr[], int size)
{
 for(int i=0; i<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
}
// 驱动程序代码
int main()
{
 int arr[] = {12, 30, 45, 6, 99, 88, 7};
 int size = sizeof(arr)/sizeof(arr[0]);
 // 打印原始数组
 cout << "原始数组: " << endl;
 printArrayElements(arr, size);
 // 反转数组
 reverseArr(arr, size);
 // 打印反转数组
 cout << "反转数组: " << endl;
 printArrayElements(arr, size);
 return 0;
}

输出:

原始数组: 
12 30 45 6 99 88 7 
反转数组: 
7 88 99 6 45 30 12 

使用循环反转数组的 Python 程序

下面是使用循环反转数组的 Python 程序:

# 使用循环反转列表元素的Python程序
def reverseList(arr, size):
    i = 0
    j = size-1
    while i<size/2:
        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()
# 驱动代码
arr = [512, 330, 245, 116, 99, 88, 77]
size = len(arr)
# 打印原始数组
print("原始数组:")
printListElements(arr, size)
# 反转数组
reverseList(arr, size)
# 打印反转数组
print("反转数组:")
printListElements(arr, size)

输出:

原始数组:
512 330 245 116 99 88 77 
反转数组:
77 88 99 116 245 330 512 

使用循环反转数组的 JavaScript 程序

下面是使用循环反转数组的 JavaScript 程序:

// 使用 JavaScript 程序循环来反转数组的元素
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<size; i++) {
 document.write(arr[i] + " ");
 }
 document.write("<br>");
}
// 驱动代码
var arr = [512, 330, 245, 116, 99, 88, 77];
var size = arr.length;
// 打印原始数组
document.write("原始数组: " + "<br>");
printArrayElements(arr, size);
// 反转数组
reverseArr(arr, size);
// 打印反转数组
document.write("反转数组: " + "<br>");
printArrayElements(arr, size);

输出:

原始数组: 
512 330 245 116 99 88 77 反转数组: 77 88 99 116 245 330 512

反转数组的递归方法

问题陈述

你得到一个数组arr。您需要反转数组的元素,然后打印反转的数组。您需要使用递归来实现此解决方案。

示例 1:设 arr = [45, 12, 67, 63, 9, 23, 74]

反转 arr = [74, 23, 9, 63, 67, 12, 45]

因此输出为 74 23 9 63 67 12 45。

示例 2:设 arr = [1, 2, 3, 4, 5, 6, 7, 8]

反转 arr = [8, 7, 6, 5, 4, 3, 2, 1]

因此输出为 8 7 6 5 4 3 2 1。

使用递归反转数组的方法

您可以按照以下方法使用递归来反转数组的元素:

  1. 初始化索引变量startend,使它们分别指向数组的第一个 (0) 和最后一个 (sizeOfArray – 1) 索引。
  2. 将索引start处的元素与索引end处 的元素交换。
  3. 递归调用 reverse 函数。在 reverse 函数的参数中,start的值加 1, end的值减1。
  4. 当开始变量的值大于或等于结束变量的 值时停止递归。

使用递归反转数组的 C++ 程序

下面是使用递归反转数组的 C++ 程序:

// C++程序使用递归反转数组
#include <iostream>
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<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
}
// 驱动代码
int main()
{
int arr[] = {12, 30, 45, 6, 99, 88, 7};
int size = sizeof(arr)/sizeof(arr[0]);
// 打印原始数组
cout << "原始数组: " << endl;
printArrayElements(arr, size);
// 反转数组
reverseArr(arr, 0, size-1);
// 打印反转数组
cout << "反转数组: " << endl;
printArrayElements(arr, size);
return 0;
}

输出:

原始数组: 
12 30

 45 6 99 88 7 
反转数组: 
7 88 99 6 45 30 12 

使用递归反转数组的 Python 程序

下面是使用递归反转数组的 Python 程序:

# Python程序使用递归反转数组
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()
# 驱动代码
arr = [12, 30, 45, 6, 99, 88, 7]
size = len(arr)
# 打印原始数组
print("原始数组:")
printListElements(arr, size)
# 反转数组
reverseList(arr, 0, size-1)
# 打印反转数组
print("反转数组:")
printListElements(arr, size)

输出:

原始数组:
12 30 45 6 99 88 7 
反转数组:
7 88 99 6 45 30 12

使用递归反转数组的 JavaScript 程序

下面是使用递归反转数组的 JavaScript 程序:

// JavaScript程序使用递归反转数组
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<size; i++)
 {
 document.write(arr[i] + " ");
 }
 document.write("<br>");
}
// 驱动代码
var arr = [45, 12, 67, 63, 9, 23, 74];
let size = arr.length;
// 打印原始数组
document.write("原始数组: " + "<br>");
printArrayElements(arr, size);
// 反转数组
reverseArr(arr, 0, size-1);
// 打印反转数组
document.write("反转数组: " + "<br>");
printArrayElements(arr, size);

输出:

原始数组: 
512 330 245 116 99 88 77
反转数组: 
77 88 99 116 245 330 512

使用递归解决问题

递归函数是调用自身的函数。在递归中,通过将问题分解成更小、更简单的版本来解决问题。

递归有很多优点:递归代码比迭代代码短,它可以用来解决自然递归的问题,它可以用于中缀、前缀、后缀评估,递归减少了编写和调试代码等

递归是技术面试中面试官最喜欢的话题。您必须了解递归以及如何在编写代码时使用它,才能成为最高效的程序员。

发表回复