Java 如何实现无递归的合并排序

数组的大小总是2的幂，并且不能递归

如果我在提问时犯了错误，这是我第一次提问。请容忍我

该计划是将标记以二的幂放置，然后循环，并将有序的数字放入一个数组中，然后将它们放回数组中。然后，应将其放置到拆分到的组中的原始数组中。逐渐变大，直到整个数组被排序

public static void MergeSortNonRec(long[] a) {
    //======================
    //FILL IN YOUR CODE HERE
    //======================    

    System.out.println(a.length);  // print statement
    if (a == null) 
        return;
    int subArray1 = 0;
    int subArray2 = 1;
    int increment = 0;

    int swapCounter = 0;

    for (int i = 1; i <= a.length; i *= 2) {
        // this loop determines the current size of the sub array
        increment = i;
        subArray1 = 0;
        subArray2 = 0;
        swapCounter = 0;

        while (subArray2 <= a.length) {
            // this will loop until we reach the end of the array

            subArray2 += increment;

            long[] spareArray = new long[2 * i];
            swapCounter = 0;
            while (swapCounter <= spareArray.length) {
                System.out.println(subArray1 + " " + subArray2); // print statement
                if (a[subArray1] < a[subArray2]) {
                    spareArray[swapCounter] = a[subArray1];
                    swapCounter++;
                    subArray1++;
                } else
                if (a[subArray1] > a[subArray2]) {
                    spareArray[swapCounter] = a[subArray2];
                    swapCounter++;
                    subArray2++;
                } else
                if (a[subArray1] == a[subArray2]) {
                    spareArray[swapCounter] = a[subArray1];
                    swapCounter++;
                    subArray1++;
                    System.out.println(swapCounter + " " + subArray1); // print statement
                    spareArray[swapCounter] = a[subArray1];
                    swapCounter++;
                    subArray2++;
                }
            } // this creates an array of the ordered elements 

            while (swapCounter == spareArray.length) {
                subArray1 -= swapCounter / 2;
                subArray2 -= swapCounter / 2;
                // now the sub array pointers are back to the values they started at
                int spareArrayPointer = 0;
                for (; subArray1 <= subArray2; subArray1++) {
                    a[subArray1] = spareArray[spareArrayPointer];
                    spareArrayPointer++;
                } // this places the values in the spare array into the original array
                subArray1 -= spareArrayPointer;
                spareArrayPointer = 0;
                // takes the first pointer back to where it started
            }
            subArray1 += increment;
            subArray2 += increment + increment;
        } // end subArray2 <= a.length loop
    } // end 2*i loop
} //MergeSortNonRec()

publicstaticvoidmergesortnonrec（长[]a）{
//======================
//在这里填写您的代码
//======================    
System.out.println（a.length）；//打印语句
如果（a==null）
回来
int子阵列1=0；
int子阵列2=1；
整数增量=0；
int swapCounter=0；
对于（inti=1；i，合并排序的非递归实现仍然可以基于自顶向下的合并排序，使用堆栈推送和弹出索引对

非递归合并排序的一种更常见的实现是自下而上，其中n个元素的数组被视为大小为1的n个“已排序”运行（因为它们的大小为1，可以将它们视为已排序），然后对于每个合并“过程”，合并偶数和奇数运行，这将使每个过程的运行大小加倍。重复此操作，直到运行大小>=数组大小

Wiki示例。此示例可以通过在每个过程后交换A和B来优化，以更改每个过程的合并方向，并避免除lass过程外的复制（或提前确定过程数，并在执行合并过程之前交换到位，以运行大小=2开始）

所有递归都可以作为循环展开，像merge sort这样古老而常见的算法已经有很多文章介绍了如何使用for或while循环来实现它。Web搜索应该会产生大量的结果