十大经典排序算法:
# 分为两类:
非线性时间比较类排序:通过比较决定元素间的相对次序,由于时间复杂度不能突破O(nlogn),称之为非线性时间比较类排序。
线性时间非比较类排序:不通过比较决定元素间的相对顺序,突破基于比较排序的时间下界,以线性时间运行,称之为线性时间非比较类排序。
# 排序算法:
非线性时间比较类排序:
1)交换排序:冒泡排序,快速排序
2)插入排序:简单插入排序,希尔排序
3)选择排序:简单选择排序,堆排序
4)归并排序:二路归并排序,多路归并排序
线性时间非比较类排序:
1)计数排序
2)桶排序
3)基数排序
1. 冒泡排序(Bubble Sort):比较两个元素,如果前一个大于后一个,交换
public static int[] bubbleSort(int[] arr){
int arrLen = arr.length;
for (int i = arrLen - 1; i >= 1; i--) {
for (int j = 0; j < i; j++) {
if (arr[j] > arr[j+1]) {
swap(arr, j, j+1);
}
}
}
return arr;
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
2. 快速排序(Quick Sort):通过一趟排序,将记录分为两个独立的部分,其中一部分的关键字比另一部分小,可以分别
对于这两个部分进行排序,达到有序的效果。
从数列中选出一个元素,称为“基准”(pivot)
重新排序数列,所有比基准值小的元素放在基准值的前面,比基准值大的元素放在基准值的后面,分区结束后,基准
值处于数列的中间,称之为分区(partition)操作
递归地处理子数列
public static void QuickSort(int[] arr, int start, int end) {
if (start < end) {
int index = partition(arr, start, end);
QuickSort(arr, start, index - 1);
QuickSort(arr, index + 1, end);
}
}
public static int partition(int[] arr, int start, int end) {
int pivot = arr[start];
while (start < end) {
while (start < end && arr[end] >= pivot){
end--;
}
arr[start] = arr[end];
while (start < end && arr[start] < arr[pivot]) {
start++;
}
arr[end] = arr[start];
}
arr[start] = pivot;
return start;
}
3. 简单插入排序(Insertion Sort):从第一个元素开始,该元素表示为有序,取出下一个元素,在已经排序的元素序列中
从后向前扫描,如果以及排序好的元素大于新的元素,该元素后移,直到找到其位置。
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int j = i - 1;
int currentValue = arr[i];
while(j >= 0 && arr[j] > currentValue) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = currentValue;
}
}
4.希尔排序(Shell sort):简单插入排序的改进版本,与插入排序不同之处在于,优先比较距离比较元的元素,缩小增量排序
将整个待排序的记录序列分割称为若干个子序列分别进行插入排序,具体算法:
选择一个增量序列t1,t2,...,tk,其中ti>tj,tk = 1
按照增量序列的个数K,对于序列进行k趟排序;
每趟排序,根据对应的增量ti,将待排序列分割为长度为m的子序列,分别对各个子表进行直接插入排序,仅增量因子为1
时候,整个序列作为一个表处理,表长度为整个序列的长度。
public static void shellSort(int[] arr){
int gap = 1;
while (gap < arr.length / 3) {
gap = gap*3+1;
}
while (gap >= 1) {
for (int i = gap; i < arr.length; i++) {
for (int j = i; j >= gap && arr[j] < arr[j-gap]; j-= gap) {
swap(arr, j, j-gap);
}
}
gap /= 3;
}
}
5. 简单选择排序(Selection Sort):在未排序的序列中找到最小(最大)元素,存放到排序序列的起始位置,从
剩余的未排序的元素中找到最小(最大)元素,放到已经排序的末尾,直到所有元素排序完成。
public static void selectionSort(int[] arr){
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
int tmp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = tmp;
}
}
6.堆排序(heap Sort):利用堆的数据结构设计的一种排序算法,堆是一个近似完全二叉树的结构,同时满足堆的性质:
子节点的键值总是小于或者大于其父节点。
算法描述:
将初始待排序的关键字序列(R1,R2,...,Rn)构建成为大顶堆
将堆顶的元素R[1]与最后一个元素R[n]交换,对于(R1, R2,...,Rn-1)调整为新的堆,再次将R[1]与最后一个元素
交换得到新的无序区,不断重复直到有序区的元素为n-1个,整个排序过程完成。
public static void heapSort(int[] arr) { //整体程序
maxHeap(arr);//得到大顶堆
int len = arr.length;
while(len > 1) {
exchange(arr, 0, len - 1); //交换
len--; //长度减一
heapify(arr, 0, len); //调整堆
}
}
public static void exchange(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static void heapify(int[] arr, int i, int len) {
int tmp = arr[i];
for (int k = 2*i+1; k < len; k = 2*k+1) {
if (k+1 < len && arr[k] < arr[k+1]) {
k++;
}
if (tmp < arr[k]) {//tmp和arr[k]进行比较
arr[i] = arr[k];
i = k;
}
else{
break;
}
}
arr[i] = tmp;
}
public static void maxHeap(int[] arr) {
int len = arr.length;
for (int i = len/2 - 1; i >= 0; i--) {
heapify(arr, i, len);
}
}
7.二路归并排序(Merge Sort):归并排序是建立在归并操作上的一种有效的排序算法,采用分治法的一个典型应用,
将已经有序的子序列合并,得到完全有序的序列,使得每个子序列有序,再使得子序列段间有序。
算法描述:
将长度为n的输入序列分为两个长度为n/2的子序列
对于两个子序列分别使用归并排序
将两个排序好的序列合并为最终的一个排序序列
public static void mergeSort(int[] arr, int low, int high) {
if (arr.length == 1)
return;
if (low < high) {
int middle = (low + high) / 2;
mergeSort(arr, low, middle);
mergeSort(arr, middle+1, high);
merge(arr, low, middle, high);
}
}
public static void merge(int[] arr, int low, int middle, int high){
int[] result = new int[high - low + 1];
int k =0;
int i = low;
int j = middle + 1;
while(i <= middle && j <= high) {
if (arr[i] < arr[j]) {
result[k++] = arr[i++];
}
else{
result[k++] = arr[j++];
}
}
while (i <= middle) {
result[k++] = arr[i++];
}
while (j <= high) {
result[k++] = arr[j++];
}
System.arraycopy(result,0,arr,low,result.length);
}
基数排序,计数排序,桶排序都使用了桶的概念,但是对于桶的使用方法有明显的差异:
基数排序:根据键值的每位数字来分配桶
计数排序:每个桶只存储单一键值
桶排序:每个桶存储一定范围的数值
8.计数排序(Count Sort):计数排序不是基于比较的排序算法,核心在于将数据值转化为键存储再额外开辟的数组
空间中,作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是具有确定的范围的整数。
算法描述:
找出待排序的数组的最大和最小的元素
统计数组中每个值为i的元素出现的次数,存入数组C的第i项
public static void countSort(int[] arr, int maxValue) {
int[] bucket = new int[maxValue + 1];
for (int i = 0; i < arr.length; i++) {
bucket[arr[i]]++;
}
int k = 0; //arr的索引
for (int i = 0; i <= maxValue;) {
while (bucket[i] != 0) {
arr[k++] = i;
bucket[i]--;
}
i++;
}
}
9.桶排序
桶排序是计数排序的升级版本,利用函数的映射关系,高效与否在于这个映射函数的确定,为了使得桶排序更加
高效,需要:
在额外空间充足的情况下,尽量增大桶的数量
使用映射函数能够将输入的N个数据均匀的分配到K个桶中,对于桶中的元素,使用何种排序算法对于性能的影响
至关重要。
10.基数排序(Radix Sort):按照低位先排序,然后收集,再按照高位排序,然后再收集,以此类推,直到最高位,
有时候,有些属性是有优先级的,先按照低优先级排序,再按照高优先级排序,最后的次序就是高优先级高的在前,
高优先级相同的低优先级高的在前。
算法描述:
取得数组中的最大数,取得位数
arr为原始的数组,从最低位置开始取每个位组成radix数组
对于radix进行计数排序(利用计数排序适用于小范围数的特点)
public static void radixSort(int[]arr){
//最大值
int maxNum = arr[0];
for(int i = 1; i < arr.length; i++){
if(maxNum < arr[i]){
maxNum = arr[i];
}
}
//位数
int level = 0;
while (maxNum > 0) {
maxNum /= 10;
level++;
}
//排序
int[][] bucket = new int[10][arr.length];
int[] bCount = new int[10];
int index = 0;//索引当前到了第几位
int radix = 1;
while(index < level) {
//按照某位输入数组中
for (int i = 0; i < arr.length; i++){
int k = (arr[i]/radix)%10;
bucket[k][bCount[k]++] = arr[i];
}
//从数组中输出
int k = 0;
for(int i = 0; i < arr.length;){
int cur = 0;
while(cur < bCount[k]){
arr[i++] = bucket[k][cur++];//不能使用--bCount[k],应该首先取底下
}
k++;
}
//bCount置0
Arrays.fill(bCount, 0);
//自增
index++;
radix *= 10;
}
}