十大排序算法（超详细）
绪论
身为程序员，十大排序是对每一个程序员都应该掌握的算法，现在比较流行的算法如快速排序、归并排序等，对算法的时间复杂度和空间复杂度的掌握都有要求。本文将分享常见的十大排序算法，基于Java和C语言实现，让你能够掌握！
对于排序的分类，可以根据不同的角度比如时间、空间复杂度、比较非比较等角度来划分。我们通常的十大排序都是内部排序，通常的话，基于[比较和非比较]这个层次来划分：
（1）交换类
[1]冒泡排序
基本思想：循环遍历多次，每次从前往后把大元素往后调，每次确定一个最大（最小）元素，多次到达排序序列。
实现代码：（Java）
/*
* 1、冒泡排序
*/
public static void maoPaoSort(int[] array) {
for(int i=array.length-1;i>=0;i--) {
for(int j=0;j<i;j++) {
if(array[j]>=array[j+1]) {
int t=array[j];
array[j]=array[j+1];
array[j+1]=t;
}
}
}
}
实现代码：（C语言）
void bubble_sort(int a[], int n)
{
int i,j,temp;
for (j=0;j<n-1;j++)
{
for (i=0;i<n-1-j;i++)
{
if(a[i]>a[i+1])
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
}
}
}
[2]快速排序
基本思想：将一个序列分为2部分，序列左边全部小于一个数，序列右边全部大于一个数。然后利用递归的思想再将左序列当成一个完整的序列再进行排序，同样把序列的右侧也当成一个完整的序列进行排序。
实现代码：（Java）
/*
* 2、快速排序
*/
public static void quickSort(int[] array,int left,int right) {
int low=left;
int high=right;
if(low>high) {
return ;
}
int k=array[low];
while(low<high) {
while(low<high&&array[high]>=k) {
high--;
}
array[low]=array[high];
while(low<high&&array[low]<=k) {
low++;
}
array[high]=array[low];
}
array[low]=k;
quickSort(array,left,low-1);
quickSort(array,low+1,right);
}
实现代码：（C语言）
void QuickSort(int* data, int left, int right, int direction)
{
int i = left, j = right, index = data[left];
if (data == NULL)
return;
if (right >= sizeof(*data)/sizeof(int))return;
if (left < 0)
return;
if (left >= right)
return;
while(i<j)
{
while(data[j]<=index)
j--;
data[i] = data[j];
while(data[i]>=index&&i < j)
i++;
data[j]=data[i];
}
data[i]=index;
QuickSort(data,left,i-1,direction);
QuickSort(data,i+1,right,direction);
}
（2）插入类
[3]直接插入排序
基本思想：简单的说，就是按身高来排序，从第一个开始，如果前面有比自己高的，就直接插入到合适的位置。一直到队伍的最后一个完成插入，整个队列才能满足有序。
实现代码：（Java）
/*
* 直接插入排序
*/
public static void insertSort(int[] array) {
int temp=0;
for(int i=1;i<array.length;i++) {
temp=array[i];
for(int j=i-1;j>=0;j--) {
if(array[j]>temp) {
array[j+1]=array[j];
array[j]=temp;
}else {
break;
}
}
}
}
实现代码：（C语言）
void insertsort(int *k,int n)
{
int i,j;
int temp;
for(i=1;i<n;i++)
{
temp = k[i];
j = i - 1;
while(j>=0 && k[j]>temp)
{
k[j+1] = k[j];
j--;
}
k[j+1] = temp;
}
}
[4]希尔排序
基本思想：希尔排序是特殊的插入排序，直接插入排序每次插入前的遍历步长为1，而希尔排序是将待排序列分为若干个子序列，对这些子序列分别进行直接插入排序，当每个子序列长度为1时，再进行一次直接插入排序时，结果一定是有序的。常见的划分子序列的方法有：初始步长（两个子序列相应元素相差的距离）为要排的数的一半，之后每执行一次步长折半。
实现代码：（Java）
/*
* 希尔排序
*/
public static void shellSort(int[] array) {
int len=array.length;
int temp=0;
for(;len>=1;len/=2) {
for(int i=len;i<array.length;i++) {
temp=array[i];
for(int j=i-len;j>=0;j-=len) {
if(array[j]>temp) {
array[j+len]=array[j];
array[j]=temp;
}else {
break;
}
}
}
}
}
实现代码：（C语言）
void shellSort(int *a, int len)
{
int i, j, k, tmp, gap;
for(gap=len/2;gap>0;gap/=2) {
for(i=0;i<gap;++i) {
for(j=i+gap;j<len;j+=gap) {
tmp=a[j];
k=j-gap;
while(k>=0&&a[k]>tmp) {
a[k+gap]=a[k];
k-=gap;
}
a[k+gap]=tmp;
}
}
}
}
（3）选择类
[5]简单选择排序
基本思想：首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。
实现代码：（Java）
/*
* 简单选择排序
*/
public static void selectSort(int[] array) {
for(int i=0;i<array.length-1;i++) {
int min=i;
for(int j=i+1;j<array.length;j++) {
if(array[j]<array[min]) {
min=j;
}
}
if(min!=i) {
swap1(array,i,min);
}
}
}
public static void swap1(int[] array,int i,int j) {
int t=array[i];
array[i]=array[j];
array[j]=t;
}
实现代码：（C语言）
void SelectSort(int a[],int n){
int mix,temp;
int i,j;
for(i=0;i<n-1;i++){
mix=i;
for(j=i+1;j<n;j++)
if(a[j]<a[mix])
mix=j;
if(i!=mix) {
temp=a[i];
a[i]=a[mix];
a[mix]=temp;
}
}
}
[6]堆排序
基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
实现代码：（Java）
/*
* 堆排序
*/
public static void swap2(int[] array,int m,int n) {
int t=array[m];
array[m]=array[n];
array[n]=t;
}
public static void shiftDown(int[] array,int index,int len) {
int left=index*2+1;
int right=index*2+2;
if(left>=len) {
return ;
}else if(right<len&&array[right]<array[index]&&array[right]<array[left]) {
swap2(array, index, right);
shiftDown(array, right, len);
}else if(array[left]<array[index]) {
swap2(array, index, left);
shiftDown(array, left, len);
}
}
public static void createHeap(int[] array) {
for(int i=array.length/2;i>=0;i--) {
shiftDown(array, i,array.length);
}
}
public static void heapSort(int[] array) {
int[] val=new int[array.length];
createHeap(array);
for(int i=0;i<array.length;i++) {
val[i]=array[0];
array[0]=array[array.length-1-i];
shiftDown(array, 0, array.length-i);
}
for(int i=0;i<array.length;i++) {
array[i]=val[i];
}
}
实现代码：（C语言）
void AdjustDown(DataType* a, size_t n, int parent)
{
int child = parent * 2 + 1;
while(child < n)
{
if((child + 1 < n)&&(a[child+1]>a[child]))
{
++child;
}
if(a[child]>a[parent])
{
Swap(&a[child], &a[parent]);
parent=child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(DataType* a, size_t n)
{
assert(a);
for(int i = (n - 2) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while(end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}
（4）归并类
[7]归并排序
基本思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并, 使用中牺牲空间换取时间的算法。
实现代码：（Java）
/*
* 归并排序
*/
public static void mergeSort(int[] array,int left,int right) {
int mid=(left+right)/2;
if(left<right)
{
mergeSort(array, left, mid);
mergeSort(array, mid+1, right);
merge(array, left,mid, right);
}
}
public static void merge(int[] array,int l,int mid,int r) {
int lindex=l;
int rindex=mid+1;
int temp[]=new int[r-l+1];
int teamindex=0;
while (lindex<=mid&&rindex<=r) {
if(array[lindex]<=array[rindex])
{
temp[teamindex++]=array[lindex++];
}else {
temp[teamindex++]=array[rindex++];
}
}
while(lindex<=mid)
{
temp[teamindex++]=array[lindex++];
}
while(rindex<=r)
{
temp[teamindex++]=array[rindex++];
}
for(int i=0;i<teamindex;i++)
{
array[l+i]=temp[i];
}
}
实现代码：（C语言）
void merge(int arr[], int start, int mid, int end) {
int result[ArrLen];
int k = 0;
int i = start;
int j = mid + 1;
while (i <= mid && j <= end) {
if (arr[i] < arr[j]){
result[k++] = arr[i++];
}
else{
result[k++] = arr[j++];
}
}
if (i == mid + 1) {
while(j <= end)
result[k++] = arr[j++];
}
if (j == end + 1) {
while (i <= mid)
result[k++] = arr[i++];
}
for (j = 0, i = start ; j < k; i++, j++) {
arr[i] = result[j];
}
}
void mergeSort(int arr[], int start, int end) {
if (start >= end)
return;
int mid = ( start + end ) / 2;
mergeSort(arr, start, mid);
mergeSort(arr, mid + 1, end);
merge(arr, start, mid, end);
}
（5）桶类排序
[8]桶排序
基本思想：把数组中的所有元素分为若干个数据块，也就是若干个桶，然后对每个桶里的数据进行排序，最后将所有桶里的数据依次排列即可。
实现代码：（Java）
/*
* 桶排序
*/
public static int[] bucketSort(int[] nums, int maxNum){
int[] sorted = new int[maxNum+1];
for(int i=0; i<nums.length; i++){
sorted[nums[i]] = nums[i]; //把数据放到对应索引的位置
}
return sorted;
}
实现代码：（C语言）
typedef struct node {
int key;
struct node *next;
}KeyNode;
void bucket_sort(int keys[],int size,int bucket_size) {
int i,j;
KeyNode **bucket_table = (KeyNode **)malloc(bucket_size * sizeof(KeyNode*));
for(i = 0;i < bucket_size;i++) {
bucket_table[i] = (KeyNode*)malloc(sizeof(KeyNode));
bucket_table[i]->key = 0;
bucket_table[i]->next = NULL;
}
for(j = 0;j < size;j++) {
KeyNode *node = (KeyNode *)malloc(sizeof(KeyNode));
node->key = keys[j];
node->next = NULL;
int index = keys[j]/10;
KeyNode *p = bucket_table[index];
if(p->key == 0) {
bucket_table[index]->next = node;
(bucket_table[index]->key)++;
}else {
while(p->next != NULL && p->next->key <= node->key)
p = p->next;
node->next = p->next;
p->next = node;
(bucket_table[index]->key)++;
}
}
KeyNode * k = NULL;
for(i = 0;i < bucket_size;i++)
for(k = bucket_table[i]->next;k!=NULL;k=k->next)
printf("%d ",k->key);
printf("\n");
}
[9]计数排序
基本思想：先找到最小值min，再找最大值max。然后创建这个区间大小的数组，从min的位置开始计数，这样就可以最大程度地压缩空间，提高空间的使用效率。
实现代码：（Java）
/*
* 计数排序
*/
public static void countSort(int[] array) {
int min=Integer.MAX_VALUE;
int max=Integer.MIN_VALUE;
for(int i=0;i<array.length;i++)
{
if(array[i]<min)
min=array[i];
if(array[i]>max)
max=array[i];
}
int count[]=new int[max-min+1];
for(int i=0;i<array.length;i++)
{
count[array[i]-min]++;
}
int index=0;
for(int i=0;i<count.length;i++)
{
while (count[i]-->0) {
array[index++]=i+min;
}
}
}
[10]基数排序
基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。在每一次排序中，按照当前位把数组元素放到对应的桶当中，然后把桶0到桶9中的元素按先进先出的方式放回数组中。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
实现代码：（Java）
/*
* 基数排序
*/
public static void radixSort(int[] array) {
List<Integer> bucket[]=new ArrayList[10];
for(int i=0;i<10;i++)
{
bucket[i]=new ArrayList<Integer>();
}
int max=0;
for(int i=0;i<array.length;i++)
{
if(array[i]>max)
max=array[i];
}
int divideNum=1;
while (max>0) {
for(int num:array)
{
bucket[(num/divideNum)%10].add(num);
}
divideNum*=10;
max/=10;
int idx=0;
for(List<Integer>list:bucket)
{
for(int num:list)
{
array[idx++]=num;
}
list.clear();
}
}
}
结语
十大排序算法就分享给大家了！下面是对算法的总结：
