快速排序和归并排序

比较

两种算法都是分治(Divide and Conquer)算法。。

但是快速排序是先整体(<= pivot pivot >= pivot)后局部…..

原地操作。。。具有稳定性。。平均O(nlogn)

而归并排序是先局部(小数组排好序)后整体(排好序的小数组Merge)

空间复杂为O(n)…..稳定。。。都是O(nlogn)

Code:

快速排序：

public class QuickSort {
public static void sortIntegers(int[] nums){
if (nums == null || nums.length == 0){
return;
}
quickSort(nums, 0 ,nums.length - 1);
}
private static void quickSort(int[] nums, int start, int end){
if (start >= end){
return;
}
int left = start, right = end;
int pivot = nums[(start + end) / 2];
//parttion
while (left <= right){
while (left <= right && nums[left] < pivot){
left++;
}
while (left <= right && nums[right] > pivot){
right--;
}
if (left <= right){
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
left++;
right--;
}
}
quickSort(nums, start, right);
quickSort(nums, left, end);

}

细节：

这里要注意pivot取得是元素，而不是下标。。另外left <= right 可以避免子数组相交。为了切分均匀，nums[xx] 与pivot之间没有等号。。

归并排序：

public class MergeSort {
public static void sortIntegers(int[] nums){
int[] tmp = new int[nums.length];
mergeSort(nums, 0, nums.length - 1, tmp);
}
private static void mergeSort(int[] nums, int start, int end, int[] tmp){
if (start >= end){
return;
}
int mid = (start + end) /2;
mergeSort(nums, start, mid, tmp);
mergeSort(nums, mid + 1, end, tmp);
merge(nums, start, end, tmp);

}
private static void merge(int[] nums, int start, int end, int[] tmp){
int mid = (end + start) /2;
int left = start, right = mid + 1;
int index = start;

while (left <= mid && right <= end){
if (nums[left] < nums[right]){
tmp[index++] = nums[left++];
}
else{
tmp[index++] = nums[right++];
}
}
while(left <= mid){
tmp[index++] = nums[left++];
}
while(right <= end){
tmp[index++] = nums[right++];
}
for(int i = start; i <= end; i++){
nums[i] = tmp[i];
}
}

细节：

为了节约辅助数组的操作时间，这里是当做参数传进来的。。。

无脑归并操作，一定要记住。。。