排序算法总结
最近在看左神的算法视频，随便记录下自己的学习心得，方便以后review，也让大家对基本的排序算法有个了解。
冒泡排序
冒泡排序（英语：Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
最简单的排序算法，实际工作中根本不会用到，因为时间复杂度为O(n^2),成本太高了。
排序过程
简单的说，就是两层循环的嵌套，给你n个数，每一次循环，排好一个最大或最小的数，重复上述这个过程，直到n-1次循环结束，就得到了从小到大排列的有序数列。
排序过程图解
关键代码：
public static void bubblesort(int[] arr) {
//第一种写法,每一次循环确定一个最大数
for (int i = 0; i < arr.length - 1; i++) { //循环的次数
for (int j = 0; j < arr.length - 1 - i; j++) { //比较的次数
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
}
}
}
// //第二种写法，每一次循环确定一个最小数
// for (int i = 0; i < arr.length - 1; i++) {
// for (int j = arr.length - 1; j > i; j--) {
// if (arr[j - 1] > arr[j]) {
// swap(arr, j - 1, j);
// }
// }
// }
}
//交换数组中两个数的位置
public static void swap(int[] arr, int m, int n) {
int t = arr[m];
arr[m] = arr[n];
arr[n] = t;
}
选择排序
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
时间复杂度O(n^2)，选择排序的优点主要与数据移动有关，对n个元素的排序最多进行n-1次交换。
排序过程图解
关键代码
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++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr, i, minIndex);
}
}
public static void swap(int[] arr, int m, int n) {
int t = arr[m];
arr[m] = arr[n];
arr[n] = t;
}
插入排序
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
时间复杂度为O(n^2)
排序过程图解
关键代码
public static void insertionsort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
swap(arr, j, j + 1);
}
}
}
public static void swap(int[] arr, int m, int n) {
int t = arr[m];
arr[m] = arr[n];
arr[n] = t;
}
归并排序
归并排序（英语：Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法，效率为O(N*logN)（大O符号）。1945年由约翰·冯·诺伊曼首次提出。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。
时间复杂度为O(N*logN)
排序过程图解
关键代码
//划分
public static void mergesort(int[] arr) {
if(arr==null||arr.length<2){
return;
}
mergesort(arr,0,arr.length-1);
}
public static void mergesort(int[] arr,int l,int r){
if(l==r){
return;
}
int mid=l+((r-l)>>1);
//划分成左右两块
mergesort(arr,l,mid);
mergesort(arr,mid+1,r);
//对左右两块进行排序并合并
merge(arr,l,mid,r);
}
//归并
public static void merge(int[] arr, int l, int m,int r) {
int[] tmp=new int[r-l+1]; //申请一个临时数组用来存储
int i=0;
int p1=l;
int p2=m+1;
while(p1<=m&&p2<=r){
tmp[i++]=arr[p1]<arr[p2]?arr[p1++]:arr[p2++];
}
//两个while只会执行一个
while(p1<=m){
tmp[i++]=arr[p1++];
}
while(p2<=r){
tmp[i++]=arr[p2++];
}
//将排好序的数组tmp复制到数组arr中
for(int j=0;j<tmp.length;j++){
arr[l+j]=tmp[j];
}
}
堆排序
堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
时间复杂度为O(N*logN)
排序过程图解
关键代码
//堆排序
public static void heapsort(int[] arr) {
//数组为空或者长度为1直接返回
if(arr==null||arr.length<2){
return;
}
for(int i=0;i<arr.length;i++){
heapinsert(arr,i);
}
int size=arr.length;
//将堆顶元素和最后一个元素交换，然后再调整堆结构
swap(arr,0,--size);
while(size>0){
heapify(arr,0,size);
swap(arr,0,--size);
}
}
//往最大堆中插入数据
public static void heapinsert(int[] arr,int index) {
//孩子节点的值与双亲节点的值进行比较
while(arr[index]>arr[(index-1)/2]){
swap(arr,index,(index-1)/2);
index=(index-1)/2;
}
}
//调整最大堆的结构
public static void heapify(int[] arr,int index,int size) {
int left=2*index+1;
while(left<size){
//largest为最大值的下标
int largest=left+1<size&&arr[left+1]>arr[left]?left+1:left;
largest=arr[largest]>arr[index]?largest:index;
if(largest==index){
break;
}
swap(arr,largest,index);
index=largest;
left=2*index+1;
}
}
public static void swap(int[] arr, int m, int n) {
int t = arr[m];
arr[m] = arr[n];
arr[n] = t;
}
快速排序
快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序n个项目要O(nlogn)（大O符号）次比较。在最坏状况下则需要O(n^2)次比较，但这种状况并不常见。事实上，快速排序O(nlogn)通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地达成。
时间复杂度为O(N*logN)
排序过程图解
关键代码
一般的写法：将左边第一个元素作为基准，每次从右往左找到第一个小于基准元素的下标，然后从左往右找到第一个大于基准元素的下标，最后，再交换这两个元素的值。重复上面的过程。
public static void quicksort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
quicksort(arr, 0, arr.length - 1);
}
public static void quicksort(int[] arr, int left, int right) {
if (left >= right) {
return;
}
int tmp = arr[left];
int i = left;
int j = right;
while (i < j) {
while (arr[j] >= tmp && i < j) {
j--;
}
while (arr[i] <= tmp && i < j) {
i++;
}
if (i < j) {
swap(arr, i, j);
}
}
swap(arr, left, i);
quicksort(arr, left, i - 1);
quicksort(arr, i + 1, right);
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
进阶的写法：可以减少递归的次数，因为返回的区间不包含重复的元素。
例如，[3,1,2,3,3,4]
第一种写法，划分的区间是：[2,1]和[3,3,4]
第二种写法，划分的区间是：[2,1]和[4]
public static void quicksort(int[] arr) {
if(arr==null||arr.length<2){
return;
}
quicksort(arr,0,arr.length-1);
}
public static void quicksort(int[] arr,int l,int r){
if(l<r){
//随机挑选数组中的一个元素与右边的元素交换,时间复杂度为O(nlogn)，叫做随机快排
swap(arr,l+(int)((r-l+1)*Math.random()),r);
int[] p=partion(arr,l,r);
quicksort(arr,l,p[0]);
quicksort(arr,p[1],r);
}
}
//返回以基准划分后的小于和大于基准边界的下标值
public static int[] partion(int[] arr,int l,int r){
//less表示小于基准的下标值
int less=l-1;
//刚开始让more指向数组最后一个元素，不参与下面的交换，最后要让其归位，more表示大于基准的下标值
int more=r;
//循环的条件l<more
while(l<more){
if(arr[l]<arr[r]){
swap(arr,++less,l++);
}else if(arr[l]>arr[r]){
swap(arr,l,--more);
}else{
l++;
}
}
//将基准元素归位
swap(arr,more,r);
return new int[]{less,more+1};
}
public static void swap(int[] arr, int m, int n) {
int t = arr[m];
arr[m] = arr[n];
arr[n] = t;
}
基数排序
基数排序（英语：Radix sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数.
时间复杂度：O(d * (n + r))
排序过程图解
关键代码
public static void radixSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
radixSort(arr, 0, arr.length - 1, maxbits(arr));
}
//返回待排序数组的最大位数
public static int maxbits(int[] arr) {
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
}
int res = 0;
while (max != 0) {
res++;
max /= 10;
}
return res;
}
//digit：最大位数，
public static void radixSort(int[] arr, int begin, int end, int digit) {
final int radix = 10;
int i = 0, j = 0;
int[] count = new int[radix];
int[] bucket = new int[end - begin + 1];
for (int d = 1; d <= digit; d++) {
for (i = 0; i < radix; i++) {
count[i] = 0;
}
// 统计将数组中的数字分配到桶中后，各个桶中的数字个数
for (i = begin; i <= end; i++) {
j = getDigit(arr[i], d);
count[j]++;
}
// 将各个桶中的数字个数，转化成各个桶中最后一个数字的下标索引
for (i = 1; i < radix; i++) {
count[i] = count[i] + count[i - 1];
}
// 将原数组中的数字分配给辅助数组 bucket
for (i = end; i >= begin; i--) {
j = getDigit(arr[i], d);
bucket[count[j] - 1] = arr[i];
count[j]--;
}
/*
错误写法,会使得之前位数的排好的序混乱
for (i = begin; i<=end; i++) {
j = getDigit(arr[i], d);
bucket[count[j] - 1] = arr[i];
count[j]--;
}
*/
//将bucket复制给arr
for (i = begin, j = 0; i <= end; i++, j++) {
arr[i] = bucket[j];
}
}
}
//返回对应位数上的数
public static int getDigit(int x, int d) {
return ((x / ((int) Math.pow(10, d - 1))) % 10);
}
计数排序
计数排序（Counting sort）是一种稳定的线性时间排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。
时间复杂度：O(n+k)
排序过程图解
关键代码
public static void countingsort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
}
int[] bucket = new int[max + 1];
for (int i = 0; i < arr.length; i++) {
bucket[arr[i]]++;
}
int i = 0;
for (int j = 0; j < bucket.length; j++) {
while (bucket[j]-- > 0) {
arr[i++] = j;
}
}
}
排序算法性能比较
