Печатайте каждый проход алгоритмов сортировки слиянием и быстрой сортировки

Question

Я пытаюсь вывести каждый проход алгоритма сортировки слиянием и быстрой сортировки, который я написал для домашнего задания, но у меня возникают небольшие трудности с определением, что именно печатать, когда печатать и где размещатьпечать заявления.В дополнение к печати значений мне также необходимо заключать в скобки массивы, созданные алгоритмом, в каждом проходе, как показано ниже:

Образец сортировки слиянием желаемый вывод:

[ 4     85     94     68     76     75     40     66     18 ]
[ 4     85     94     68     76 ] [ 75     40     66     18 ]
[ 4     85     94 ] [ 68     76 ] [ 75     40 ] [ 66     18 ]
[ 4     85 ] [ 94 ] [ 68 ] [ 76 ] [ 75 ] [ 40 ] [ 66 ] [ 18 ]
[ 4     85 ] [ 94 ]    
[ 4 ] [ 85 ]  
[ 4     85 ]    
[ 4     85     94 ] [ 68     76 ] [ 40     75 ] [ 18     66 ] 
[ 4     68     76     85     94 ] [ 18     40     66     75 ]
[ 4     18     40     66     68     75     76     85     94 ]

Образец быстрой сортировки желаемый вывод:

[ 47     44     39     77     80     19     49     45     65 ]
[ 44     39     19     45 ] [ 47 ] [ 77     80     49     65 ]
[ 39     19 ] [ 44 ] [ 45 ] [ 47 ] [ 49     65 ] [ 77 ] [ 80 ]
[ 19 ] [ 39 ] [ 44 ] [ 45 ] [ 47 ] [ 49 ] [ 65 ] [ 77 ] [ 80 ]

Мой класс только начинает изучать стеки и рекурсивные функции, поэтому я сейчас немного застрял.Вот мои две функции для каждого алгоритма сортировки:

Алгоритм сортировки слиянием:

public static void MergeSort(int[] array) {
    int size = array.length;
    if (size < 2)
        return;
    int mid = size / 2;
    int leftSize = mid;
    int rightSize = size - mid;
    int[] left = new int[leftSize];
    int[] right = new int[rightSize];

    for (int i = 0; i < mid; i++) {
        left[i] = array[i];

    }

    for (int i = mid; i < size; i++) {
        right[i - mid] = array[i];
    }

    MergeSort(left);
    MergeSort(right);
    Merge(array, left, right);
}

public static void Merge(int[] array, int[] left, int[] right) {
    int leftSize = left.length;
    int rightSize = right.length;
    int i = 0, j = 0, k = 0;

    while (i < leftSize && j < rightSize) {
        if (left[i] <= right[j]) {
            array[k] = left[i];
            i++;
            k++;
        } else {
            array[k] = right[j];
            k++;
            j++;
        }
    }

    while (i < leftSize) {
        array[k] = left[i];
        k++;
        i++;
    }

    while (j < rightSize) {
        array[k] = right[j];
        k++;
        j++;
    }
}

Быстрая сортировка:

public static void QuickSort(int[] array, int left, int right) {
    int pivotIndex = left + (right - left) / 2;
    int pivotValue = array[pivotIndex];

    int i = left;
    int j = right;

    while(i <= j) {
        while(array[i] < pivotValue) {
            i++;
        }

        while(array[j] > pivotValue) {
            j--;
        }

        if(i <= j) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            i++;
            j--;
        }

        if(left < i) {
            QuickSort(array, left, j);
        }

        if(right > i) {
            QuickSort(array, i, right);
        }
    }
}