1.排序
1.选择排序
不稳定，一般不用，基本排序
思路：过滤数组，找到最小数，放在前面。
不稳：导致原本在前的数据移动到后面。
int arr[];
for(i=0;i<arr.length-1;i++){
int smallest=i;
for(j=i+1;j<length;j++){
if(arr[j]<arr[smallest]){
smallest=j;
}
swap(arr,i,smallest);
}
}
时间复杂度O(n2)，空间复杂度O(1)
2.冒泡排序
稳定，不常用，太慢，基本排序
思路：从第一个数两两比较，然后大的向后交换位置。
int arr[];
for(i=arr.length-1;i>0;i--){
for(j=0;j<i;j++){
if(arr[j]>arr[j+1]){
swap[arr,j,j+1]
}
}
}
时间复杂度O(n2)，空间复杂度O(1)
3.插入排序
稳定，三种基本排序中最常用，在数据较少且有一定次序时效率很高
思路：从第二位向后过滤，向前逐位比较并与更小的交换直到大于或等于。
int arr[];
for(i=1;i<arr.length-1;i++){
for(j=i;i>0;i--){
if(arr[j-1]>arr[j]) swap(arr,j-1,j);
}
}
时间复杂度O(n2)，空间复杂度O(1)
4.希尔排序
稳定，是优化过的插入排序
思路：按一定数据间隔将数据分组进行插入排序，然后缩小间隔进行，直到为1。
问：为什么比插入排序更优？
答：分组大时，换位次数少。分组小时，换位距离短。
int arr[];
int h=1;
while(h<=arr.length/3){
h=h*3+1; //计算Knuth数列
}
for(gap=h;gap>0;gap=(gap-1)/3){ //缩小间隔
for(i=gap;i<arr.length;i++){
for(j=i;j>gap-1;j-=gap){
if(arr[j-gap]>arr[j]) swap(arr,j-gap,j); //每组进行插入排序
}
}
时间复杂度O(n^1.3)，空间复杂度O(1)
5.归并排序
稳定，对于预先有一定次序的数组效率很高
思路：将数组递归地分为两部分，然后两个部分中的数依次比较，较小的填入中间数组。
public void sort(int[] arr,left,right){
if(left==right) return; //边界判定，何时停止
int mid=left-(left+right)/2; //递归中点计算
sort(arr,left,mid); //左侧递归
sort(arr,mid+1,right); //右侧递归
merge(arr,left,mid,right); //进行分组排序
print(arr);
}
public void merge(int[] arr,leftPtr,rightPtr,rightBound){
int temp[]=new int[leftPtr-rightBound+1]; //定义中间数组
int i=leftPtr; //定义左指针，右指针
int j=rightPtr;
int k=-1;
while(i<rightPtr&&j<rightBound){
temp[k++] = arr[i] <= arr[j] ? arr[++i] : arr[++j]; //将左指针和右指针指向的数小的放入中间数组
}
while(i<rightPtr-1) temp[k++]=arr[i++]; //将左侧剩余数放入中间数组
while(j<rightBound) temp[k++]=arr[j++]; //将右侧剩余数放入中间数组
for(int m=0;m<temp.length;m++) arr[leftPtr+m]=temp[m]; //将中间数组放入原数组
}
时间复杂度O(N log N)，空间复杂度O(N)
6.快速排序
不稳
原理：选出一个数，将比它小的数放到它左侧，比它大的数放到它右侧。
可优化位双轴快速排序（java中对较大数组的排序方法）
/*
*@param left 左边界
*@param right 右边界
*/
public void sort(arr[],left,right){
//边界判断
if(left>=right) return;
//初始化左右指针
int i=left;
int j=right;
//将最后一位定为pivot
int pivot=arr[right];
while(i<j){
//如果左侧比pivot大，则与右侧比pivot小的换位
while(arr[i]<=pivot) i++;
while(arr[j]>pivot) j--;
//如果左指针大于等于右指针说明本次排序结束
if(i>=j) break;
swap(arr,i,j);
}
if(arr[i]<=pivot){
swap(arr,i+1,right); //将pivot放在中间，此时，左侧比pivot小，右侧比pivot大
}else{
swap(arr,i,right);
}
sort(arr[],left,i-1); //左侧递归
sort(arr[],i,right); //右侧递归
}
时间复杂度O(N log N)，空间复杂度O(1)
7.计数排序
桶排序的一种，非比较排序，稳定（优化后），对于数量大但数据大小数量少的情况效率很高
思路：将每种数据的数量放入中间数组中，然后按放回原数组中。
int arr[];
//进行取数组最大值，最小值的步骤，在此处省略，并初始化min，max为最小最大值
int max;
int min;
sort(arr,max,min){
int count=new int[max-min+1]; //设置计数桶
int temp[arr.length]; //初始化中间数组
for(i=0;i<arr.length;i++){
count[arr[i]-min]++; //计数
}
for(j=0;j<count.length;j++){
count[j+1]+=count[j]; //优化步骤，此时桶中存储的是该数据最后一位的位置
}
for(k=arr.length;k>=0;k--){
temp[--count[ arr[k]-min ]] = arr[k]; //优化步骤，从原数组最后开始过滤，将数据放到对应位置
}
return temp;
}
时间复杂度O(N+K)，空间复杂度O(N+K) （K是计数桶大小）
8.基数排序
桶排序的一种，非比较排序，基于技术排列，稳定
思路：对数据每一位上进行计数排列
从最低位开始的基数排序
int arr[];
//对最高位进行计算，此处跳过此步骤，直接初始化变量h为最高位数
int h;
sort(arr,h){
int count=new int[10]; //设置计数桶，此时只有0-9
int temp[arr.length]; //初始化中间数组
for(m=0;m<h;m++){
int divison=(int)Math.pow(10,m); //求10的m次幂
for(i=0;i<arr.length;i++){
count[arr[i]/divison%10]++; //计数
}
for(j=0;j<count.length-1;j++){ //优化步骤，此时桶中存储的是该数据最后一位的位置
count[j+1]+=count[j];
}
for(k=arr.length;k>=0;k--){ //优化步骤，从原数组最后开始过滤，将数据放到对应位置
temp[--count[arr[k]]]=arr[k];
}
}
return temp;
}
从最高位开始的基数排序
递归思想
int arr[];
//对最高位进行计算，此处跳过此步骤，直接初始化变量h为最高位数
int h;
sort(arr,h){
if(h=1) return temp;
int divison=(int)Math.pow(10,h); //求10的i次幂
int count=new int[10]; //设置计数桶，此时只有0-9
int temp[arr.length]; //初始化中间数组
for(i=0;i<arr.length;i++){
count[arr[i]/divison%10]++; //计数
}
for(j=0;j<count.length-1;j++){ //优化步骤，此时桶中存储的是该数据最后一位的位置
count[j+1]+=count[j];
}
sort(arr,h-1);
for(k=arr.length;k>=0;k--){ //优化步骤，从原数组最后开始过滤，将数据放到对应位置
temp[--count[arr[k]]]=arr[k];
}
}
时间复杂度O(N_K)，空间复杂度O(N_K) （K是计数桶大小）
9.桶排序
不常用，效率低
思路：将数据区域分为几个“桶”，将数据放入对应的“桶”中，对每个桶进行排序（其他排序方法或者递归）。
10.堆排序
堆排序是利用堆这种数据结构设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为 O(NlogN)，不稳定
思路：将数组转换成一个堆（视情况使用大顶堆或者小顶堆，此处为大顶堆），将最大值下沉（第一位和最后一位换位），将其他位数转换成堆，直到数组有序。
public static void heapSort(int arr[]) {
int temp = 0;
for(int i = arr.length / 2 -1; i >=0; i--) {
adjustHeap(arr, i, arr.length);
}
for(int j = arr.length-1;j >0; j--) {
swap(i,j);
adjustHeap(arr, 0, j);
}
}
//将一个数组(二叉树), 调整成一个大顶堆
/**
* 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆
* @param arr 待调整的数组
* @param ptr 表示非叶子结点在数组中索引
* @param length 表示对多少个元素继续调整， length 是在逐渐的减少
*/
public static void adjustHeap(int arr[], int ptr, int length) {
// k = ptr * 2 + 1 k 是 ptr 结点的左子结点
for(int k = ptr * 2 + 1; k < length; k = k * 2 + 1) {
//判断，避免遍历左右子树
if(k+1 < length && arr[k] < arr[k+1]) { //如果左子节点比右子节点小，则转向右子节点
k++;
}
//子节点判断
if(arr[k] > arr[ptr]) {
swap(arr,ptr,j)
ptr = k; //对子树进行调整，避免结构混乱
} else {
break;
}
}
}
时间复杂度 O(N*Log N)，空间复杂度O(1)
