1、快速排序
适合数据量大,排序时间短,具体代码如下:
package ds.sort;
/**
* @author : cuantianhou 2019/12/16
*/
public class QuickSort {
/**
* 主要思路:取基准数据,从数据高位寻找小于基准数据的值,然后用目标值替换低位置的值,
* 然后从低位置寻找大于基准数据的值,
*
*
*/
/**
*
* @param arr 比较的数组
* @param start 起始位置
* @param end 结束位置
* @param <T> 泛型
*/
public <T extends Comparable> void quickSort(T [] arr,int start, int end){
if(start >= end){
return;
}
//记录基准数据
T base = arr[start];
while(start < end){
while(start < end && arr[end].compareTo(base)>=0) {
end --;
}
arr[start] = arr[end];
while(start < end && arr[start].compareTo(base)<=0){
start ++;
}
arr[end] = arr[start];
}
arr[start] = base;
quickSort(arr,0,start-1);
quickSort(arr,start+1,end);
}
}
2、归并排序
将数组分块排序,然后合并,完成排序,具体代码如下:
package ds.sort;
import java.lang.reflect.Array;
/**
* @author : cuantianhou 2019/12/16
*/
public class MergeSort {
public<T extends Comparable<T>> void mergeSort(T []arr){
merge(arr,0,arr.length-1,arr[0].getClass());
}
private <T extends Comparable<T>> void merge(T []arr, int left, int right,Class<?> elementClass){
if(left == right){
return;
}
int mid = (left+right)>>1;
merge(arr,left,mid,elementClass);
merge(arr,mid+1,right,elementClass);
sort(arr,left,mid,right,elementClass);
//打印每次排序结果
for(int l = 0; l < arr.length-1; l ++){
System.out.print(arr[l]+",");
}
System.out.println(arr[arr.length-1]);
}
private<T extends Comparable<T>> void sort(T []arr, int left , int mid, int right, Class<?> elementClass){
//构造一个临时数组
T[] temp = (T[])Array.newInstance(elementClass,right-left+1);
//记录当前索引
int i = 0;
int m = left;
int n = mid + 1;
//比较左右两个元素,哪个小,把哪个元素放入临时数组中
while(m <= mid && n <= right){
temp[i++] = arr[m].compareTo(arr[n])== -1 ? arr[m++]: arr[n++];
}
while(m<=mid){
temp[i++] = arr[m++];
}
while(n<=right){
temp[i++] = arr[n++];
}
//把最终的排序结果复制给原数组
for(int j = 0; j < temp.length; j++){
arr[left+j] = temp[j];
}
}
}