排序算法比较
一、数组形式排序
1、快速排序
示例：
public class QuickSort {
public static void quickSort(int[] arr, int low, int high){
int i,j,temp,t;
// 当 low>high 时一次循环就结束
if(low>high){
return;
}
i=low;
j=high;
// temp 就是基准位
temp = arr[low];
while (i<j) {
// 先看右边，依次往左遍历，直到找到小于 temp 的值或者 i=j 时停止遍历
while (temp<=arr[j]&&i<j) {
j--;
}
// 再看左边，依次往右遍历，直到找到大于 temp 的值或者 i=j 时停止遍历
while (temp>=arr[i]&&i<j) {
i++;
}
// 如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}
}
// 最后将基准为与 i 和 j 相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
// 递归调用左半数组
quickSort(arr, low, j-1);
// 递归调用右半数组
quickSort(arr, j+1, high);
}
public static void main(String[] args){
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2、堆排序（大根堆）
堆排序是一种树形选择排序方法，它的特点是：在排序的过程中，将 array[0，…，n-1] 看成是一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子结点之间的内在关系，在当前无序区中选择关键字最大（最小）的元素。
若 array[0，…，n-1] 表示一颗完全二叉树的顺序存储模式，则双亲节点指针和孩子结点指针之间的内在关系如下：
堆的定义：
建立大根堆：
堆排序（大根堆）:
堆排序算法的性能分析：
建立大根堆
//构建大根堆：将array看成完全二叉树的顺序存储结构
private int[] buildMaxHeap(int[] array){
//从最后一个节点array.length-1的父节点（array.length-1-1）/2开始，直到根节点0，反复调整堆
for(int i=(array.length-2)/2;i>=0;i--){
adjustDownToUp(array, i,array.length);
}
return array;
}
//将元素array[k]自下往上逐步调整树形结构
private void adjustDownToUp(int[] array,int k,int length){
int temp = array[k];
for(int i=2*k+1; i<length-1; i=2*i+1){ // i 初始化为当前节点的左孩子，每次沿节点较大的子节点向下调整
if(i<length && array[i]<array[i+1]){ // 取节点较大的子节点的下标
i++; // 如果节点的右孩子>左孩子，则取右孩子节点的下标
}
if(temp>=array[i]){ //根节点 >=左右子女中关键字较大者，调整结束
break;
}else{ //根节点 <左右子女中关键字较大者
array[k] = array[i]; //将左右子结点中较大值array[i]调整到双亲节点上
k = i; //【关键】修改k值，以便继续向下调整
}
}
array[k] = temp; //被调整的结点的值放人最终位置
}
堆排序
//堆排序
public int[] heapSort(int[] array){
array = buildMaxHeap(array); //初始建堆，array[0]为第一趟值最大的元素
for(int i=array.length-1;i>1;i--){
int temp = array[0]; //将堆顶元素和堆低元素交换，即得到当前最大元素正确的排序位置
array[0] = array[i];
array[i] = temp;
adjustDownToUp(array, 0,i); //整理，将剩余的元素整理成堆
}
return array;
}
3、归并排序
归并排序（Merge）是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
（1）自顶向下
代码
public class Main {
public static void main(String[] args) {
int[] arr = {11,44,23,67,88,65,34,48,9,12};
int[] tmp = new int[arr.length]; //新建一个临时数组存放
mergeSort(arr,0,arr.length-1,tmp);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
public static void merge(int[] arr,int low,int mid,int high,int[] tmp){
int i = 0, j = low, k = mid+1; //左边序列和右边序列起始索引
while(j <= mid && k <= high){
if(arr[j] < arr[k]){
tmp[i++] = arr[j++];
}else{
tmp[i++] = arr[k++];
}
}
//若左边序列还有剩余，则将其全部拷贝进tmp[]中
while(j <= mid){
tmp[i++] = arr[j++];
}
while(k <= high){
tmp[i++] = arr[k++];
}
for(int t=0;t<i;t++){
arr[low+t] = tmp[t];
}
}
public static void mergeSort(int[] arr,int low,int high,int[] tmp){
if(low<high){
int mid = (low+high)/2;
mergeSort(arr,low,mid,tmp); //对左边序列进行归并排序
mergeSort(arr,mid+1,high,tmp); //对右边序列进行归并排序
merge(arr,low,mid,high,tmp); //合并两个有序序列
}
}
}
（2）自底向上
二、链表形式的排序
三、常用的排序 API 与数据结构
1、Arrays.sort()
（1）API
（2）源码
public static void sort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
（3）执行流程
2）为什么要判断结构
2、Collections
3、优先级队列
队列是一种先进先出（FIFO）的数据结构，但是有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的元素先出队列。Java 集合框架中提供了 PriorityQueue 和 PriorityBlockingQueue 两种类型的优先级队列，PriorityQueue 是线程不安全的，PriorityBlockingQueue 是线程安全的，这里主要使用 PriorityQueue。PriorityQueue 的底层是堆，堆的底层是数组。
（1）PriorityQueue 使用注意点
（2）PriorityQueue 的扩容方式
（3）构造函数
（4）插入/删除/获取优先级最高的元素
