引言
本篇是排序算法的第三篇，归并排序和快速排序。
归并排序
1、算法步骤
归并算法采用分治策略，如下图（图片来自网络）：
从上图可以看出算法步骤是：
1、先将待排序序列用二分法形式递归的分开。
2、再将分开的数据排序后递归的合并。
2、时间复杂度
平均时间复杂度O(n log n)
3、算法实现
public class MergeSort {
public static void main(String[] args) {
int[] numbers = {12,2,24,30,6,16};
int[] result = MergeSort.sort(numbers);
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < result.length; i++) {
stringBuffer.append(result[i] + " ");
}
System.out.println(stringBuffer.toString());
}
public static int[] sort(int[] number){
//重新copy一个新数组，不影响参数
int[] needSort = Arrays.copyOf(number, number.length);
//无需排序
if(needSort.length < 2){
return needSort;
}
//下面步骤是对半分开
int middle = (int)Math.floor(needSort.length/2);
int[] left = Arrays.copyOfRange(needSort, 0, middle);
int[] right = Arrays.copyOfRange(needSort,middle,needSort.length);
//递归对半先分开，再并排序
return merge(sort(left),sort(right));
}
//排序
protected static int[] merge(int[] left,int[] right){
//新数组存放结果集
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length > 0 && right.length > 0){
if(left[0] < right[0]){
result[i++] = left[0];
left = Arrays.copyOfRange(left,1,left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right,1,right.length);
}
}
while (left.length > 0){
result[i++] = left[0];
left = Arrays.copyOfRange(left,1,left.length);
}
while (right.length > 0){
result[i++] = right[0];
right = Arrays.copyOfRange(right,1,right.length);
}
return result;
}
}
快速排序
快速排序也是一种分治思想，这个分治思想真的值得好好感悟下，排序不仅仅是一种算法，最重要的是体会这种思想！
1、算法步骤
1、从待排序的序列中找一个数，作为本次比较的基准。 2、将比基准小的放到基准前面，比基准大的放到基准后面。 3、重复上述操作，直到排序完成。
2、时间复杂度
平均时间复杂度O(n log n)
3、算法实现
public class QuickSort {
public static void main(String[] args) {
int[] numbers = {12,2,24,30,6,16};
int[] result = QuickSort.sort(numbers);
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < result.length; i++) {
stringBuffer.append(result[i] + " ");
}
System.out.println(stringBuffer.toString());
}
public static int[] sort(int[] number){
//copy 数组
int[] neeedSort = Arrays.copyOf(number, number.length);
//此时是第一组
quickSort(neeedSort,0,neeedSort.length - 1);
return neeedSort;
}
//以每组第一个为基准
public static void quickSort(int[] arg,int left,int right){
if(left < right){
int partiton = partition(arg, left, right);
quickSort(arg,left,partiton - 1);
quickSort(arg,partiton + 1,right);
}
}
//返回下一次分组的中间位置，并排序好
public static int partition(int[] arg,int left,int right){
int partition = left;
int index = partition + 1;
for (int i = index;i<=right;i++){
if(arg[i] < arg[partition]){
swap(arg,i,index);
index++;
}
}
//将基准设置到中间位置
swap(arg,partition,index - 1);
return index - 1;
}
//交换
private static void swap(int[] arg,int left,int right){
int tmp = arg[left];
arg[left] = arg[right];
arg[right] = tmp;
}
}
结束语
本篇主要介绍了快速排序，仔细品品和归并排序的区别，此时在这留一个面试题：一个文件中有1亿个数字，如何快速的找到top1000?
