java ArrayList 反转详解_arraylist倒序-CSDN博客

本文链接：https://blog.csdn.net/T_Y_F_/article/details/144227226

在 Java 中，反转一个 ArrayList 是一个常见的操作。反转的目标是将 ArrayList 的元素顺序颠倒。例如，将 [1, 2, 3, 4] 反转为 [4, 3, 2, 1]。以下是如何实现反转操作的详解。

1. 使用 `Collections.reverse()`

实现原理

Java 的 Collections 类提供了一个静态方法 reverse()，可以直接反转一个 List 的顺序。

实现代码

import java.util.ArrayList;
import java.util.Collections;

public class ReverseArrayList {
    public static void main(String[] args) {
        // 初始化 ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("Original List: " + list);

        // 使用 Collections.reverse() 反转
        Collections.reverse(list);

        System.out.println("Reversed List: " + list);
    }
}

运行结果

Original List: [1, 2, 3, 4]
Reversed List: [4, 3, 2, 1]

优点

简单高效。
方法内对原 ArrayList 进行反转，直接修改原始列表。

2. 手动实现反转

如果不想使用 Collections.reverse()，可以手动实现反转操作。

实现原理

使用双指针法。
交换 ArrayList 中的首尾元素，依次向中间移动，直到反转完成。

实现代码

import java.util.ArrayList;

public class ReverseArrayListManual {
    public static void main(String[] args) {
        // 初始化 ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("Original List: " + list);

        // 手动反转
        reverseArrayList(list);

        System.out.println("Reversed List: " + list);
    }

    public static void reverseArrayList(ArrayList<Integer> list) {
        int left = 0;
        int right = list.size() - 1;

        // 使用双指针交换元素
        while (left < right) {
            // 交换 left 和 right 索引的元素
            int temp = list.get(left);
            list.set(left, list.get(right));
            list.set(right, temp);

            // 移动指针
            left++;
            right--;
        }
    }
}

运行结果

Original List: [1, 2, 3, 4]
Reversed List: [4, 3, 2, 1]

优点

不依赖外部工具类。
可用于学习基础的算法和操作。

3. 使用栈进行反转

实现原理

使用 Stack 将 ArrayList 的元素入栈。
再逐个将栈的元素出栈，放回 ArrayList 中，从而实现反转。

实现代码

import java.util.ArrayList;
import java.util.Stack;

public class ReverseArrayListWithStack {
    public static void main(String[] args) {
        // 初始化 ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("Original List: " + list);

        // 使用栈反转
        reverseArrayListUsingStack(list);

        System.out.println("Reversed List: " + list);
    }

    public static void reverseArrayListUsingStack(ArrayList<Integer> list) {
        Stack<Integer> stack = new Stack<>();

        // 将元素入栈
        for (int num : list) {
            stack.push(num);
        }

        // 将栈中的元素重新写回列表
        for (int i = 0; i < list.size(); i++) {
            list.set(i, stack.pop());
        }
    }
}

运行结果

Original List: [1, 2, 3, 4]
Reversed List: [4, 3, 2, 1]

优点

使用栈的特性，逻辑清晰。
适合需要了解栈的基本操作时使用。

4. 使用递归反转

实现原理

递归地将第一个元素移到最后。
每次递归调用都减少问题规模。

实现代码

import java.util.ArrayList;

public class ReverseArrayListRecursive {
    public static void main(String[] args) {
        // 初始化 ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("Original List: " + list);

        // 使用递归反转
        reverseArrayListRecursive(list, 0, list.size() - 1);

        System.out.println("Reversed List: " + list);
    }

    public static void reverseArrayListRecursive(ArrayList<Integer> list, int left, int right) {
        if (left >= right) {
            return; // 递归结束条件
        }

        // 交换元素
        int temp = list.get(left);
        list.set(left, list.get(right));
        list.set(right, temp);

        // 递归反转剩余部分
        reverseArrayListRecursive(list, left + 1, right - 1);
    }
}

运行结果

Original List: [1, 2, 3, 4]
Reversed List: [4, 3, 2, 1]

优点

通过递归实现逻辑简洁。
对递归思想的实践和理解。

缺点

对于大规模列表，递归深度可能会导致栈溢出。

5. 反转后的新列表（非原地操作）

实现原理

创建一个新的 ArrayList，从旧列表中逆序插入元素。

实现代码

import java.util.ArrayList;

public class ReverseArrayListNewList {
    public static void main(String[] args) {
        // 初始化 ArrayList
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println("Original List: " + list);

        // 反转并创建新列表
        ArrayList<Integer> reversedList = reverseToNewList(list);

        System.out.println("Reversed List: " + reversedList);
    }

    public static ArrayList<Integer> reverseToNewList(ArrayList<Integer> list) {
        ArrayList<Integer> reversedList = new ArrayList<>();
        for (int i = list.size() - 1; i >= 0; i--) {
            reversedList.add(list.get(i));
        }
        return reversedList;
    }
}

运行结果

Original List: [1, 2, 3, 4]
Reversed List: [4, 3, 2, 1]

优点

不修改原列表。
适合需要保留原数据的场景。

6. 各方法对比总结

方法	特点	时间复杂度	空间复杂度	适用场景
`Collections.reverse()`	简单高效，直接修改原列表。	$O (n)$	$O (1)$	快速反转，推荐使用。
手动双指针法	不依赖工具类，原地修改列表。	$O (n)$	$O (1)$	学习链表反转算法的经典方法。
栈实现	使用栈的先进后出特性，逻辑清晰。	$O (n)$	$O (n)$	了解栈操作或需要临时存储数据时。
递归实现	使用递归思想，代码简洁。	$O (n)$	$O (n)$	适合小规模列表，递归实践场景。
创建新列表	生成新的反转列表，保留原列表。	$O (n)$	$O (n)$	原列表不能被修改的场景。