给定一个非负整数数组A (A中元素不相同，如存在元素相同，则提示用户重新输入)，返回一个数组，在该数组中的所有整数从小到大排列。 示例: 输入:A=[1,5,3,8,6,2] 输出:[1,2,3,5,6,8] 分别使用合并排序和快速排序，使用Java实现。并且给出模拟运行效果

为了返回一个按照升序排列的非负整数数组，你可以使用两种常用的排序算法——归并排序（Merge Sort）和快速排序（Quick Sort）。这里我会为你提供这两种算法在Java中的实现，并简要描述它们的工作原理。

### 归并排序（Merge Sort）
归并排序是一种分治策略，它将数组不断分割成两半，直到每个子数组只剩下一个元素。然后将这些子数组合并在一起，保持有序。

public class MergeSort {
    public int[] sort(int[] arr) {
        if (arr == null || arr.length <= 1)
            return arr;
        
        int mid = arr.length / 2;
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);
        
        return merge(sort(left), sort(right));
    }
    
    private int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        int i = 0, j = 0, k = 0;

        while (i < left.length && j < right.length) {
            if (left[i] <= right[j])
                result[k++] = left[i++];
            else
                result[k++] = right[j++];
        }

        // Copy the remaining elements
        while (i < left.length)
            result[k++] = left[i++];

        while (j < right.length)
            result[k++] = right[j++];

        return result;
    }
}

### 快速排序（Quick Sort）
快速排序也是基于分治的思想，选择一个基准值（pivot），将数组划分为两部分，一部分的所有元素都小于基准值，另一部分的所有元素都大于基准值，然后对这两部分递归地进行排序。

public class QuickSort {
    public int[] sort(int[] arr) {
        if (arr == null || arr.length <= 1)
            return arr;
        
        quickSort(arr, 0, arr.length - 1);
        return arr;
    }
    
    private void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }
    
    private int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);

        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return i + 1;
    }
    
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

**模拟运行效果：**
这两种排序算法的时间复杂度都是O(n log n)，在实际应用中，快速排序通常比归并排序更快，因为它有较小的常数因子。当你对大量数据进行排序时，可以看到它们的效率差异：

- 归并排序：稳定的排序过程，适合数据量较大或需要稳定排序的场景。
- 快速排序：对于小到中等规模的数据，性能良好，但在最坏情况下可能会退化到O(n^2)，但是通过随机化优化可以降低这种情况发生的概率。