冒泡排序、归并排序、快速排序

题目：给你一个整数数组 nums，请你将该数组升序排列。
示例 ：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]

方法一：冒泡排序法
class Solution {
public int[] sortArray(int[] nums) {
for(int i = nums.length-1;i>=1;i–){
for(int j = 1;j<=i;j++){
if(nums[j-1]>nums[j]){
swap(nums,j,j-1);
}

        }
    }
    return nums;
}
private void swap(int[] nums,int i,int j){
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

}

方法二：归并排序

class Solution {
public int[] sortArray(int[] nums) {
mergeSort(nums,0,nums.length-1);
return nums;
}

private void mergeSort(int[] nums, int left, int right) {  // 需要左右边界确定排序范围
    if (left >= right) return;
    int mid = (left+right) / 2;

    mergeSort(nums, left, mid);                           // 先对左右子数组进行排序
    mergeSort(nums, mid+1, right);

    int[] temp = new int[right-left+1];                   // 临时数组存放合并结果
    int i=left,j=mid+1;
    int cur = 0;
    while (i<=mid&&j<=right) {                            // 开始合并数组
        if (nums[i]<=nums[j]) temp[cur] = nums[i++];
        else temp[cur] = nums[j++];
        cur++;
    }
    while (i<=mid) temp[cur++] = nums[i++];
    while (j<=right) temp[cur++] = nums[j++];

    for (int k = 0; k < temp.length; k++) {             // 合并数组完成，拷贝到原来的数组中
        nums[left+k] = temp[k];
   }
}

}

方法三：快速排序法
class Solution {
public int[] sortArray(int[] nums) {
int left = 0;
int right = nums.length-1;
quickSort(nums,left,right);
return nums;
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}

private void quickSort(int[] nums, int left, int right) {
		    if (left >= right) return;
		    int lo = left+1;               // 小于分界点元素的最右侧的指针
		    int hi = right;                // 大于分界点元素的最左侧的指针
		    while (lo<=hi) {
		        if (nums[lo]>nums[left]) { // 交换元素确保左侧指针指向元素小于分界点元素
		                if(nums[hi]<nums[left]){
		                                swap(nums, lo, hi);
		                                lo++;
		                                hi--;
		                            }else{
		                                hi--;
		                            }
		        } else {
		            lo++;
		        }
		    }
		    lo--;                          // 回到小于分界点元素数组的最右侧
		    swap(nums, left, lo);          // 将分界点元素移到左侧数组最右侧
		    quickSort(nums, left, lo-1);
		    quickSort(nums, lo+1, right);  

}
}