反转字符数组而不创建新数组

Question

如何原地反转数组（不创建新数组）？

Answer 1

public static int[] reverseArrayWithoutTempArray(int[] array) {
    int i = 0, j = array.length - 1;
    for (i = 0; i < array.length / 2; i++, j--) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
}

Answer 2

家庭作业意味着仅来自我的伪代码，您通过不指定您想要的语言而变得相对容易:-)

把它变成你选择的语言：

Set i1 to index of first element in array
Set i2 to index of last element in array
while i1 < i2:
    Set temporary variable to element number i1
    Set element number i1 to element number i2
    Set element number i2 to temporary value
    Add 1 to i1
    Subtract 1 from i2

理想的做法是在您的脑海中实际运行该算法，使用一张纸来跟踪变量：

• 数组中的每个元素。
• i1 和 i2。
• temporary variable。

对于更简单的算法，我倾向于这样做。我将调试语句插入到更难的那些中，以便计算机可以为我完成这项繁重的工作。从一张纸开始：

i1 | i2 | tempvar | el[0] | el[1] | el[2] | el[3] | el[4] | el[5]
---+----+---------+-------+-------+-------+-------+-------+------
                      H       e       l       l       o       !

然后一步一步地完成这些步骤，检查和/或更改每一列。这将使您了解它的工作原理，而不仅仅是给出一些代码。

Answer 3

在不使用 java 创建新数组的情况下反转字符数组。

import java.util.*;


//Reverse string array
public static void reverseArray(String[] array){

    int middle = array.length / 2;

    String temp;
    int j = array.length -1;

    for (int i = 0 ; i < middle; i++) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
        j--;
    }

    System.out.println(Arrays.toString(array));
}

如果要反转int数组，则必须将public static void reverseArray(String[] array)改为public static void reverseArray(int[] array)，将String temp改为int temp。

例子：

public static void main (String[] args) throws java.lang.Exception{
      String[] array = {"Smith", "Peter", "Michel", "John"};
      reverseArray(array);
}

输出：

[John, Michel, Peter, Smith]

Answer 4

不断交换末端，使用单个变量作为临时缓冲区。在伪代码中：

temp = a[0]
a[0] = a[size - 1]
a[size - 1] = temp

等等。

Answer 5

public static void main(String args[]){
            int j=arr.length;       
for(int i=0;i<arr.length/2;i++){
            int temp=arr[i];
            arr[i]=arr[j-1-i];
            arr[j-1-i]=temp;}
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

Answer 6

不要费心在内存中反转数组，只需向后迭代它！

Answer 7

这是在不使用临时变量或其他数组的情况下反转数组元素的解决方案。这仅适用于 Java 8 及更高版本。

void invertUsingStreams(Object[] arr2) {
    IntStream.rangeClosed(1,arr2.length)
       .mapToObj(i -> arr2[arr2.length-i])
       .forEach(System.out::println);
}

谢谢，

Answer 8

这是一个完整的程序，只需复制粘贴并在您的 IDE 中运行即可：

public class ReverseArrayWithoutAnotherArray {

public static void main(String[] args) {

    int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

    int middle = array.length / 2;

    int temp;
    int j = array.length -1;

    for(int a : array){
        System.out.println(" before reverse :: " + a);
    }
    for (int i = 0 ; i < middle; i++, j--) {
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    for(int a : array){
        System.out.println(" after reverse :: " + a);
    }
}
}

输出：

 before reverse :: 1
 before reverse :: 2
 before reverse :: 3
 before reverse :: 4
 before reverse :: 5
 before reverse :: 6
 before reverse :: 7
 before reverse :: 8
 before reverse :: 9
 before reverse :: 10
 after reverse :: 10
 after reverse :: 9
 after reverse :: 8
 after reverse :: 7
 after reverse :: 6
 after reverse :: 5
 after reverse :: 4
 after reverse :: 3
 after reverse :: 2
 after reverse :: 1

Answer 9

在不创建新数组的情况下反转字符数组

public static void main(String[] args) {
    char[] a = {'1', '2', '3','4'};
    char temp = ' ';
    for (int i = 0; i < a.length / 2; i++) {
        temp = a[i];
        a[i] = a[a.length - 1 - i];
        a[a.length - 1 - i] = temp;
    }
    System.out.println(a);
}

Answer 10

Array.prototype.reverse = function() {
  for(var i = 0, j = this.length-1; i < j; i++, j--) {
    var tmp = this[i];
    this[i] = this[j];
    this[j] = tmp;
  }
  return this;
};

Answer 11

• 使用临时变量来临时保存变量
• 使用两个索引指针，一个来自第一个索引，最后一个来自数组长度
• 迭代数组直到数组元素的中间
• 下面是我创建的函数
• 它适用于偶数和奇数大小
• 输入数组 1 4 3 2
• 预计输出 2 3 4 1

静态 int[] reverseArray(int[] a) {

    int j=a.length-1; // last index pointer

    int middle = a.length/2; // end condition

    for (int i=0;i<middle;i++){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
        j--;
    }

    return a;

}

Answer 12

var arr = [1,2,3,4,5,6]
for(let i=arr.length-2;i>=0;i--){
   arr.push(arr.splice(i,1)[0])
}
console.log(arr) // [6,5,4,3,2,1]

var arr2 = [1,2,3,4,5,6]
for(let i=0,j=arr2.length-1;i<arr2.length/2;i++){
   let temp = arr2[i];
   arr2[i] = arr2[j-i];
   arr2[j-i] = temp
}
console.log(arr2) // [6,5,4,3,2,1]

Answer 13

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

public class reversearray {
    private static Scanner scanner=new Scanner(System.in);

    public static void main(String[] args) {
        System.out.println("enter the count value ");
        int n=scanner.nextInt();
        int[] value=new int[n];
        System.out.println("enter the elements of an array");
        for(int i=0;i<n;i++)
        {
            value[i]=scanner.nextInt();
        }
        reverse(value);

    }
    public static void reverse(int[] array) {
        int n = array.length - 1;
        int temp = 0;
        int count=0;
        boolean swapped = true;
        int mid = n / 2;

        for (int i = 0; i < mid; i++) {
            temp = array[i];
            array[i] = array[n - i];
            array[n - i] = temp;
            count++;
        }
        if(count==(n-mid))
        {
            array[mid]=array[mid];
        }
        else
        {
            temp=array[mid];
            array[mid]=array[mid+1];
            array[mid+1]=temp;
        }

        System.out.println("the reveresed array elements are: " + Arrays.toString(array));
    }
}