Java 如何保存算法订购数组所需的步骤？

我目前正在尝试用Java开发一个程序，该程序必须打印算法对数组中的元素进行排序所需的步骤（每次更改数组中的所有元素），其中打印意味着在控制台中显示，将其保存为文件或SwingComponent

现在我正在使用Arraylist来保存步骤，但它只允许我在抛出异常之前对少于1k个元素进行排序

是否有其他方法可以保存更多元素的步骤

代码

包测试；
导入java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
公共类泡泡糖{
公共void排序（int[]数组，列表进程）{
int len=array.length-1；
int i，j，tmp；
process.add（array.clone（））；//保存原始数组
对于（i=0；i数组[j+1]）{
tmp=阵列[j]；
数组[j]=数组[j+1]；
阵列[j+1]=tmp；
process.add（array.clone（））；//数组已更改，请保存它
}
}
}
}
//创建一个随机数组
公共静态整数[]随机整数数组（整数最小值、整数最大值、整数金额）{
int[]数组=新int[金额]；
int total=最大-最小值；
列表<整数>数字=新数组列表（总计）；
int i=0；
对于（i=min；i

是否有其他方法可以保存更多元素的步骤

方法#1-增加堆大小。不幸的是，这无法扩展

方法#2-每次交换后不保存整个数组，只保存交换的元素对的详细信息。如有必要，您可以通过重放交换操作来重建阵列。。。从初始数组状态向前或从最终状态向后

方法#3-根本不保存步骤。排序时只需将它们输出到console/file/Swing组件

---

关于可伸缩性

• 您正在使用bubblesort，这意味着一种

  N

  元素数组涉及

  O（N^2）

  步骤
• 如果在每个步骤上对整个阵列进行快照，则需要

  O（N^3）

  内存来保存它们。对于大的

  N

  ，这是一个很大的内存
• 如果只存储交换的一对数组元素的详细信息，则内存需求将减少到

  O（N^2）

  。这仍然是很多记忆
• 如果您根本不存储细节（因为您直接输出它们！），那么对于一个简单的实现来说，内存需求将下降到

  O（N）

  。（这是将数组状态格式化为字符串所需的内存量。如有必要，您可以将其实现为

  O（1）

  。）

---

我正在使用的

O（…）

东西被调用。粗略地说，

O（N）

意味着与

N

成比例。。。as

N

趋向无穷大。这是基于极限的数学。

您使用的是冒泡排序，即O（n^2）。你会幸运地得到1000件物品。此外，实际上存储数组副本没有意义，只需在每一步打印出来即可。实际上，这只是我正在研究的三种算法之一，尝试插入和ShellSort时也会发生同样的情况。

package tests;

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

public class BubbleSort{

    public void sort( int[] array, List<int[]> process ){

        int len = array.length - 1;
        int i, j, tmp;

        process.add( array.clone() ); //Save original array
        for( i = 0; i < len; ++i ){
            for( j = 0; j < len - i; ++j ){
                if( array[ j ] > array[ j + 1 ] ){
                    tmp = array[ j ];
                    array[ j ] = array[ j + 1 ];
                    array[ j + 1 ] = tmp;
                    process.add( array.clone() ); //Array changed, save it
                }
            }
        }
    }

    //creates a random array
    public static int[] randomIntegerArray( int min, int max, int amount ){

        int[] array = new int[ amount ];
        int total = max - min;
        List< Integer > numbers = new ArrayList<>( total );
        int i = 0;

        for( i = min; i < max; ++i ){
            numbers.add( i );
        }

        Collections.shuffle( numbers );

        for( i = 0; i < amount; ++i ){

            array[ i ] = numbers.remove( 0 );
        }

        return array;
    }

    public static void main( String[] args ){
        BubbleSort bubbleSort = new BubbleSort();
        List<int[]> process = new ArrayList<>();
        int[] noError = randomIntegerArray( 0, 1000, 500 ); //Works up ~ 900
        int[] error = randomIntegerArray( 0, 1000, 1000 );

        bubbleSort.sort( noError, process);// Works
        //bubbleSort.sort( error, process);// throws java.lang.OutOfMemoryError: Java heap space in line 22

        //Print steps
        //for( int[] a : process ){ System.out.println( Arrays.toString( a ) ); }

    }

}