算法分类
比较排序：在排序的最终结果里，元素之间的次序依赖于他们之间的比较，每个数必须和其他数进行比较，才能确定自己的位置。
-
优势：适用于一切需要排序的情况。不在乎数据的分布，适用于各种规模的数据
-
冒泡排序、快速排序、插入排序、希尔排序 、堆排序、选择排序、归并排序。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以平均时间复杂度为O(nlogn)。
非比较排序：只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。时间复杂度为O(n)。
- 计数排序、基数排序、桶排序。
非比较排序的时间复杂度低，但是需要占用空间来确定唯一的位置。
递归factorial
方法内部调用方法本身
⚠️递归的层级太深容易造成栈内存溢出stackOverFlowError
冒泡排序
一次比较相邻的两个元素，如果第一个比第二个大就交换它们两个。
从第一对到结尾的最后一对，重复比较。
重复前面两个步骤（每次都能找到一轮中的最大值）。
算法分析：
最佳情况：T(n) = O(n) 最差情况：T(n) = O(n²) 平均情况：T(n) = O(n²)
public static int[] bubbleSort(int[] array){
if(array.length > 0){
for(int i=0; i<array.length; i++){
for(int j=0; j<array.length-1-i; j++){
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
return array;
}
选择排序
表现最稳定的排序算法之一，什么数据进去都是O(n²)的时间复杂度。
在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区
最佳情况：T(n) = O(n²) 最差情况：T(n) = O(n²) 平均情况：T(n) = O(n²)
public static int[] selectionSort(int[] array){
if(array.length > 0){
for(int i=0; i<array.length; i++){
int minIndex = i;
for(int j=i; j<array.length; j++){
if(array[j] < array[minIndex]){
mindex = j;
}
}
if(minIndex != i){
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
}
return array;
}
插入排序
在已排序序列中从后向前扫描，找到未排序数据的相应位置并插入。
通常采用in-place排序，即只需用到O(1)的额外空间的排序。
最佳情况：T(n) = O(n) 最差情况：T(n) = O(n²) 平均情况：T(n) = O(n²)
public static int[] insertSort(int[] array){
if(array.length > 0){
for(int i=0; i<array.length; i++){
int current = array[i+1];
int index = i;
while(index >= 0 && current < array[index]){
array[index+1] = array[index];
index--;
}
array[index+1] = current;
}
}//加入Java开发交流君样：756584822一起吹水聊天
return array;
}
希尔排序
也称为缩小增量排序，优先比较距离较远的元素。
设定增量gap，按增量分组，对每组进行插入排序，随着增量减少，每组元素越来越多，当增量到1时，所有数据被分为1组。
最佳：T(n) = O(nlog2n) 最坏：T(n) = O(nlog2n) 平均：T(n) = O(nlog2n)
public static int[] shellSort(int[] array){
if(array.length > 0){
int len = array.length;
int gap = len/2;
while(gap > 0){
for(int i=gap; i<len; i++){
int current = array[i];
int index = i - gap;
while(index >= 0 && current < array[index]){
array[index+gap] = array[index];
index -= gap;
}
array[index+gap] = current;
}
gap /= 2;
}
}
return array;
}
归并排序
始终都是O(nlogn)的时间复杂度，代价是需要额外的空间
采用分治法Divide and Conquer
先使每个子序列有序，再使子序列段间有序。
最佳情况：T(n) = O(n) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
public static int[] mergeSort(int[] array){
if(array.length < 2){
return array;
}
int mid = array.length / 2 ;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.coptOfRange(array, mid, array.length);
return merge(mergeSort(left), mergeSort(right));
}
public static merge(int[] left, int[] right){
int[] result = new int[left.length + right.length];
for(int index = 0, i=0, j=0; index<result.length; index++){
if(i >= left.length){
result[index] = right[j];
j++;
}else if(j >= right.length){
result[index] = left[i];
i++;
}else if(left[i] > right[j]){
result[index] = right[j];
j++;
}else{
result[index] = left[i];
i++;
}
}
return result;
}
快速排序
通过一趟排序将待排记录分隔成独立的两部分，其中一部分均比另一部分的小。
挑出一个元素称为基准privot
最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)
public static void quickSort(int[] array, int low, int hight){
if(low < hight){
int privotpos = partition(array, low, hight);
quickSort(array, low, privotpos-1);
quickSort(array, privotpos+1, hight);
}
}
/*
partition:
选第一个元素为基准
从hight往前看，遇到第一个比privot小的数，就放到privot的位置上
换从low往后看，遇到第一个比privot大的数，放到刚才hight的位置
再换hight...
最后空出来的位置放privot
*/
public static int partition(int[] array, int low, int hight){
int privot = array[low];
while(low < hight){
while(low < hight && array[hight] >= privot){
hight--;
}
array[low] = array[hight];
while(low < hight && array[low] <= privot){
low++;
}
array[hight] = array[low];
}
array[low] = privot;
return low;
}
堆排序
堆的定义：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。
(ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2)
堆是一颗完全二叉树，堆虽然是一颗树，但是通常存放在一个数组中，父节点和孩子节点的父子关系通过数组下标来确定。
一个节点在数组的索引怎么计算父节点及左右孩子节点的索引：
public int left(int i){
return (i+1)*2-1;
}
public int right(int i){
return (i+1)*2;
}//加入Java开发交流君样：756584822一起吹水聊天
public int parent(int i){
if(i == 0){
return -1;
}
return (i-1)/2;
}
创建一个堆
把堆首和堆尾互换
堆的尺寸减少1，重新调整堆
重复2-3步，直至减小到1
最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)
public static int[] heapSort(int[] array){
int len = array.length;
for(int i=(len/2 -1); i>=0; i--){
heapAdjust(array, i, len);
}
//堆顶元素和最后一个元素交换，并重新调整堆
for(int i=len-1; i>0; i--){
int temp = array[i];
array[i] = array[0];
array[0] = temp;
heapAdjust(array, 0, i);
}
return array;
}
//加入Java开发交流君样：756584822一起吹水聊天
public static void headAdjust(int[] array, int index, int length){
int max = index;
int lchild = 2 * index;//左子节点
int rchild = 2 * index + 1;//右子节点
if(length > lchild && array[max] < array[lchild]){
max = lchild;
}
if(length > rchild && array[max] < array[rchild]){
max = rchild;
}
//如果该节点比左右节点小，就换位置后调整堆
if(max != index){
int temp = array[index];
array[index] = array[max];
array[max] = temp;
heapAdjust(array, max, length);
}
}
计数排序
核心：将输入的数据值转化为键，存储在额外的数据空间中
找出最大值和最小值
统计每个值为i的元素出现的次数，存入数组C的第i项
反向填充目标数组：将元素i放在新数组，每放一个就将C[i]减去1
分析：当输入的元素是n个 0到k之间的整数，运行时间是O(n+k)，计数排序不是比较排序，排序的速度快于任何比较排序算法。对于数据范围很大数组，需要大量时间和内存。
最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n+k)
public static int[] countingSort(int[] array){
if(array.length == 0){
return array;
}
int bias = 0;
int min = array[0];
int max = array[0];
//找到最大值 最小值
for(int i=0; i < array.length; i++){
if(array[i] > max){
max = array[i];
}
if(array[i] < min){
min = array[i];
}
}//加入Java开发交流君样：756584822一起吹水聊天
bias = 0 - min;//偏差
int[] bucket = new int[max - min + 1];
Arrays.fill(bucket, 0);//新创建一个数组，初始化为0
for(int i=0; i<array.length; i++){
bucket[array[i] + bias] += i;
}
int index = 0;
for(int i=0; i<bucket.length; i++){
int len = bucket[i];
while(len > 0){
array[index] = i - bias;
len--;
index++;
}
}
return array;
}
桶排序
将数据分到有限数量的桶中，每个桶再分别排序（可以用别的排序）
找到待排序的最大值和最小值
桶的个数：(max-min)/arr.length +1，数值和桶的对应关系：(arr[i]-min)/arr.length
桶中每个元素都是一个链表/数组
每个桶的元素进行排序
最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n2)
public static ArrayList<ArrayList<Integer>> bucketSort(int[] array){
int max = array[0];
int min = array[0];
for(int value : arr){
max = Math.max(value, max);
min = Math.min(value, min);
}
int bucketNumber = (max - min)/array.length + 1;//定义桶的个数
ArrayList<ArrayList<Integer>> result = new ArrayList<>();//创建一个桶
for(int i=0; i<bucketNumber; i++){
result.add(new ArrayList<Integer>());
}//加入Java开发交流君样：756584822一起吹水聊天
for(int value : array){
//把元素放入桶中
result.get((value - min)/array.length).add(value);
}
for(int i=0; i<result.size(); i++){
if(result.get(i).size() > 0){
insertSort(result.get(i));//用插入排序对每个桶中的元素排序
}
}
return result;
}
基数排序
非比较的排序算法，从最低位开始对每一位排序。基数排序基于分别排序，分别收集，所以是稳定的。
低位优先
确定遍历位数
按照个位数放入相应的桶中
从桶中将元素返回，再次遍历，按照十位按序存入…
最佳情况：T(n) = O(n * k) 最差情况：T(n) = O(n * k) 平均情况：T(n) = O(n * k) k是数组中最大数的位数
public static int[] radixSort(int[] array){
if(array == null || array.lrngth < 2){
return array;
}
//先算出最大数的位数
int max = array[0];
for(int i=0; i<array.length; i++){
max = Math.max(max, array[i]);
}
int maxdigit = 0;
while(max != 0){
max = max / 10;
maxDigit ++;
}//加入Java开发交流君样：756584822一起吹水聊天
//创建桶0～9
int mod = 10, div = 1;
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for(int i=0; i<10; i++){
bucketList.add(new ArrayList<Integer>());
}
for(int i=0; i<maxDigit; i++, mod*=10, div*=10){
for(int j=0; j<array.length; j++){
int num = (array[j] % mod) / div;
bucketList.get(num).add(array[j]);
}
int index = 0;
for(int j=0; j<bucketList.size(); j++){
for(int k=0; k<bucketList.get(j).size(); k++){
array[index++] = bucketList.get(j).get(k);//从桶中取出来进行下一次排序
}
bucketList.get(j).clear();//清除桶中的数据
}
}//加入Java开发交流君样：756584822一起吹水聊天
return array;
}
