当前位置：首页 > Java

java如何实现倒置

2026-03-21 05:39:12Java

实现数组倒置的方法

在Java中，可以通过多种方式实现数组倒置。以下是几种常见的方法：

方法一：使用临时数组 创建一个与原数组大小相同的新数组，将原数组的元素从后往前复制到新数组中。

public static int[] reverseArray(int[] arr) {
    int[] reversed = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        reversed[i] = arr[arr.length - 1 - i];
    }
    return reversed;
}

方法二：原地倒置 在原数组上进行元素交换，无需额外空间。使用双指针法，一个从数组头部开始，另一个从尾部开始，交换元素直到中间位置。

public static void reverseArrayInPlace(int[] arr) {
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

方法三：使用Collections.reverse() 对于List类型的集合，可以直接使用Collections.reverse()方法进行倒置。

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

public static void reverseList(List<Integer> list) {
    Collections.reverse(list);
}

// 示例用法
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
reverseList(numbers);

方法四：使用Stream API Java 8及以上版本可以使用Stream API实现数组倒置。

import java.util.stream.IntStream;

public static int[] reverseArrayWithStream(int[] arr) {
    return IntStream.range(0, arr.length)
            .map(i -> arr[arr.length - 1 - i])
            .toArray();
}

字符串倒置的方法

方法一：使用StringBuilder.reverse() StringBuilder类提供了reverse()方法，可以方便地倒置字符串。

public static String reverseString(String str) {
    return new StringBuilder(str).reverse().toString();
}

方法二：字符数组交换 将字符串转换为字符数组，通过交换字符实现倒置。

public static String reverseStringInPlace(String str) {
    char[] chars = str.toCharArray();
    int left = 0;
    int right = chars.length - 1;
    while (left < right) {
        char temp = chars[left];
        chars[left] = chars[right];
        chars[right] = temp;
        left++;
        right--;
    }
    return new String(chars);
}

方法三：递归实现 通过递归的方式倒置字符串。

public static String reverseStringRecursive(String str) {
    if (str.isEmpty()) {
        return str;
    }
    return reverseStringRecursive(str.substring(1)) + str.charAt(0);
}

链表倒置的方法

方法一：迭代法 使用三个指针（前驱、当前、后继）遍历链表并倒置。

public static ListNode reverseList(ListNode head) {
    ListNode prev = null;
    ListNode current = head;
    while (current != null) {
        ListNode next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
    return prev;
}

方法二：递归法 通过递归调用倒置链表。

java如何实现倒置

public static ListNode reverseListRecursive(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode reversed = reverseListRecursive(head.next);
    head.next.next = head;
    head.next = null;
    return reversed;
}