十大排序算法（简介）
相关问题
1.稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
2.不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
3.时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
4.空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。
主函数和头文件
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include "list_queue.h"//堆排序时需要链式队列存储 自己写的头文件
#define LEN 15
#define swap(a,b) {typeof(a) t=a; a=b; b=t;}
void show_arr(TYPE* arr,size_t len)
{
for(int i=0; i<len; printf("%02d ",arr[i++]));
}
//定义函数指针 数组
typedef void (*SortFP)(TYPE*,size_t);
int main()
{
TYPE arr[LEN] = {};
SortFP sort[] = {bubble_sort,select_sort,insert_sort,shell_sort,quick_sort,merge_sort,merge_for_sort,heap_sort,heap_for_sort,count_sort,bucket_sort,radix_sort};
for(int i=0; i<sizeof(sort)/sizeof(sort[0]); i++)
{
for(int j=0; j<LEN; j++)
{
arr[j] = rand()%100;
printf("---");
}
printf("\n");
show_arr(arr,LEN);
printf(":排序前\n");
sort[i](arr,LEN);
}
}
1、冒泡排序（Bubble Sort）
算法概述
相对来说冒泡排序是最早接触到的排序方法，比较实用；
稳定，每次排序后，后面的元素肯定是已经排好序的，所以每次排序后可以确定一个元素在其最终的位置上，
1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元 素应该会是最大的数；
3.针对所有的元素重复以上的步骤，除了最后一个；
代码
// 冒泡排序
void bubble_sort(TYPE* arr,size_t len)
{
//节省时间flag为false结束,判断没有进行交换，已经排好序；
bool flag = true;
for(int i=len-1; i>0 && flag; i--)
{
flag = false;
for(int j=0; j<i; j++)
{
if(arr[j] > arr[j+1])
{
swap(arr[j],arr[j+1]);
flag = true;
}
}
}
show_arr(arr,len);
//返回当前函数名
printf(":%s\n",__func__);
}
2、选择排序（Selection Sort）
算法概述
数据量比较小时，每次比较往后都要平均比较。浪费时间
1.初始状态：无序区为R[1…n]，有序区为空；
2.第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个的新无序区；
3.n-1趟结束，数组有序化了。
// 选择排序
void select_sort(TYPE* arr,size_t len)
{
for(int i=0; i<len-1; i++)
{
int min = i;
for(int j=i+1; j<len; j++)
{
if(arr[j] < arr[min]) min = j;
}
if(i != min) swap(arr[i],arr[min]);
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
3、插入排序（Insertion Sort）
算法描述
数据有序，插入其他数据，比较适用
1.从第一个元素开始，该元素可以认为已经被排序；
2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5.将新元素插入到该位置后；
6.重复步骤2~5。
代码
// 插入排序
void insert_sort(TYPE* arr,size_t len)
{
for(int i=1,j=0; i<len; i++)
{
int val = arr[i];
for(j=i; j>0 && arr[j-1] > val; j--)//大于前面往后移
{
arr[j] = arr[j-1];
}
if(j != i) arr[j] = val;
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
4、希尔排序（Shell Sort）
算法概述
这个也是插入算法的优化，由于在步长跨度大，每次都是逼近有序；
1.选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2.按增量序列个数k，对序列进行k 趟排序；
3.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
// 希尔排序
void shell_sort(TYPE* arr,size_t len)
{
for(int k=len/2; k>0; k/=2)
{
for(int i=k,j=0; i<len; i++)
{
int val = arr[i];
for(j=i; j-k>=0 && arr[j-k] > val; j-=k)
{
arr[j] = arr[j-k];
}
if(j != i) arr[j] = val;
}
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
5、快速排序（Quick Sort）
算法概述
每次排序后都会出现一个正确位置，
1.从数列中挑出一个元素，称为 “基准”（pivot）；
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
//快速排序
void _quick_sort(TYPE* arr,int left,int right)
{
if(left >= right) return;//出口
int l=left,r=right;
TYPE pv = arr[l];
while(l<r)
{
while(l<r && arr[r] >= pv) r--;
arr[l] = arr[r];
while(l<r && arr[l] <= pv) l++;//l<r是出口
//arr[r]已经被备份到arr[l]
arr[r] = arr[l];
}
//回收pv到arr[l]中
arr[l] = pv;
_quick_sort(arr,left,l-1);
_quick_sort(arr,l+1,right);
}
void quick_sort(TYPE* arr,size_t len)
{
_quick_sort(arr,0,len-1);
show_arr(arr,len);
printf(":%s\n",__func__);
}
5、归并排序（Merge Sort）
算法概述
1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列。
代码
// 合并
void merge(TYPE* arr,TYPE* tmp,int l ,int p , int r)
{
if(arr[p] < arr[p+1]) return;
int k = l , i = l , j = p+1;
while(i<=p && j<=r)
{
if(arr[i] < arr[j])
tmp[k++] = arr[i++];
else
tmp[k++] = arr[j++];
}
while(i<=p) tmp[k++] = arr[i++];
while(j<=r) tmp[k++] = arr[j++];
//while(l<=r) arr[l] = tmp[l++];
memcpy(arr+l,tmp+l,sizeof(TYPE)*(r-l+1));
}
// 拆分
void _merge_sort(TYPE* arr,TYPE* tmp,int l,int r)
{
if(l >= r) return;
int p = (l+r)/2;
_merge_sort(arr,tmp,l,p);
_merge_sort(arr,tmp,p+1,r);
merge(arr,tmp,l,p,r);
}
// 归并
void merge_sort(TYPE* arr,size_t len)
{
TYPE* tmp = malloc(sizeof(TYPE)*len);
_merge_sort(arr,tmp,0,len-1);
free(tmp);
show_arr(arr,len);
printf(":%s\n",__func__);
}
void merge_for_sort(TYPE* arr,size_t len)
{
TYPE* tmp = malloc(sizeof(TYPE)*len);
TYPE* src = arr , *des = tmp;
for(int s=1; s<len; s*=2)
{
for(int l=0; l<len; l+=s*2)
{
int r = (l+s*2<len)?l+s*2:len;
int p = (l+s<len)?l+s:len;
int k = l , i = l , j = p;
while(i<p && j<r)
{
if(src[i] < src[j])
des[k++] = src[i++];
else
des[k++] = src[j++];
}
while(i<p) des[k++] = src[i++];
while(j<r) des[k++] = src[j++];
}
swap(des,src);
}
if(src != arr) memcpy(arr,src,sizeof(TYPE)*len);
free(tmp);
show_arr(arr,len);
printf(":%s\n",__func__);
}
7、堆排序（Heap Sort）
算法概述
1.将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2.将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
3.由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
//堆排序
void create_heap(TYPE* arr,int root,size_t len)
{
if(root >= len) return;//出口
int left = root*2+1 , right = root*2+2;
create_heap(arr,left,len);
create_heap(arr,right,len);
if(right < len && arr[left] < arr[right])//出口
swap(arr[left],arr[right]);
if(left < len && arr[root] < arr[left])
swap(arr[root],arr[left]);
}
void heap_sort(TYPE* arr,size_t len)
{
create_heap(arr,0,len);
for(int i=len-1; i>0; i--)
{
swap(arr[0],arr[i]);
create_heap(arr,0,i);
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
void heap_for_sort(TYPE* arr,size_t len)
{
for(int i=len-1; i>0; i--)
{
int p = (i+1)/2-1;
if(arr[i] > arr[p]) swap(arr[i],arr[p]);
}
show_arr(arr,len);
printf("\n");
for(int i=len-1; i>0; i--)
{
swap(arr[0],arr[i]);
for(int j=0; j<i; j++)
{
if(j*2+2<i && arr[j*2+1]<arr[j*2+2])
{
swap(arr[j*2+1],arr[j*2+2])
}
if(j*2+1<i && arr[j]<arr[j*2+1])
{
swap(arr[j],arr[j*2+1])
}
}
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
8、计数排序（Counting Sort）
算法概述
1.找出待排序的数组中最大和最小的元素；
2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
//计数排序
void count_sort(TYPE* arr,size_t len)
{
TYPE min = arr[0] , max = arr[len-1];
for(int i=0; i<len; i++)
{
if(arr[i] < min) min = arr[i];
if(arr[i] > max) max = arr[i];
}
TYPE* tmp = calloc(sizeof(TYPE),max-min+1);
for(int i=0; i<len; i++)
{
tmp[arr[i]-min]++;
}
for(int i=0,j=0; i<=max-min; i++)
{
while(tmp[i]--)
{
arr[j++] = i+min;
}
}
free(tmp);
show_arr(arr,len);
printf(":%s\n",__func__);
}
9、桶排序（Bucket Sort）
算法概述
1.设置一个定量的数组当作空桶；
2.遍历输入数据，并且把数据一个一个放到对应的桶里去；
3.对每个不是空的桶进行排序；
4.从不是空的桶里把排好序的数据拼接起来
//桶排序
void _bucket_sort(TYPE* arr,size_t len,int cnt,TYPE range)
{
TYPE* bucket[cnt],*bucketed[cnt];
for(int i=0; i<cnt; i++)
{
bucket[i] = malloc(sizeof(TYPE)*len);
bucketed[i] = bucket[i];
}
for(int i=0; i<len; i++)
{
for(int j=0; j<cnt; j++)
{
if(range*j<=arr[i] && arr[i]<range*(j+1))
{
*(bucketed[j]) = arr[i];
bucketed[j]++;
}
}
}
for(int i=0; i<cnt; i++)
{
int size = bucketed[i]-bucket[i];
if(size > 1) count_sort(bucket[i],size);
memcpy(arr,bucket[i],sizeof(TYPE)*size);
arr += size;
free(bucket[i]);
}
}
void bucket_sort(TYPE* arr,size_t len)
{
_bucket_sort(arr,len,4,25);
show_arr(arr,len);
printf(":%s\n",__func__);
}
10、基数排序（Radix Sort）
算法描述
1.取得数组中的最大数，并取得位数；
2.arr为原始数组，从最低位开始取每个位组成radix数组；
3.对radix进行计数排序（利用计数排序适用于小范围数的特点）
代码
//基数排序
void radix_sort(TYPE* arr,size_t len)
{
ListQueue* queue[10] = {};
for(int i=0; i<10; i++)
{
queue[i] = create_list_queue();
}
for(int i=1; i<=10&&size_list_queue(queue[0])<len; i++)
{
int mod = pow(10,i);
int div = mod / 10;
for(int j=0; j<len; j++)
{
int index = arr[j]%mod/div;
push_list_queue(queue[index],arr[j]);
}
int k = 0;
for(int j=0; j<10; j++)
{
while(!empty_list_queue(queue[j]))
{
arr[k++] = head_list_queue(queue[j]);
pop_list_queue(queue[j]);
}
}
}
for(int i=0; i<10; i++)
{
destory_list_queue(queue[i]);
}
show_arr(arr,len);
printf(":%s\n",__func__);
}
832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
