常用的几种排序算法
1.冒泡排序
相邻位置之间元素的比较
（1）算法流程
a.比较相邻位置的元素，如果左边的比右边的大，则交换两个元素的位置
b.针对每一对相邻位置的元素都重复上一步，从第一对到最后一对比较完毕 经过这一步，最后的元素就是这组数中的最大值
c.针对所有的元素重复以上步骤，每次对越来越少的元素进行比较，直到没有 可以交换的元素为止
（2）算法评价 平均时间复杂度o(n^2),稳定，对样本的有序性比较敏感
class BubbleSort {
public:
int* bubbleSort(int* A, int n) {
// write code here
bool exchange=false;
for(int i=0;i<n;i++){
for(int j=0;j<n-i-1;j++)
if(A[j]>A[j+1]){
int tmp=A[j];
A[j]=A[j+1];
A[j+1]=tmp;
exchange=true;
}
if(!exchange)
return A;
}
return A;
}
};
2.选择排序
（1）算法的流程
a.从第一数起依次取出所有元素，假定取出的元素是最小值，记录下标
b.使用假定的最小元素和后续元素依次进行比较，如果后续元素中有比
假定最小元素还小的元素，则重新记录下标，后续元素成为了假定的最小数
c.直到假定的最小元素和后续所有元素比较完毕，交互最新的最小元素和
开始假定的最小元素
d.重复上述过程，直到所有元素排序完毕
（2）算法评价
平均时间复杂度o(n^2),不稳定，对样本的有序性不敏感，比较的次数的比较多
交换的次数比较少，一般情况下略优于冒泡排序
/*
* 选择排序算法
*/
#include<stdio.h>
void sort(int arr[],int size){
int i=0,j=0;
//第一个数起依次取出所有元素
//假定最小的数为最小数，记录下标
//使用假定的最小数依次和后续元素比较
//如果后续元素比假定最小数还小则记录
//直到与后续元素比较完毕，则进行交换
for(i=0;i<size-1;i++){
int min=i;
for(j=i+1;j<size;j++){
if(arr[j]<arr[min]){
min=j;
}
}
if(min!=i){//避免和自己交换
int temp=arr[i];
arr[i]=arr[min];
arr[min]=temp;
}
}
}
int main(){
int arr[5]={5,4,3,2,1};
sort(arr,5);
int i=0;
for(i=0;i<5;i++){
printf("%d ",arr[i]);
}
printf("\n");
return 0;
}
3.插入排序
（1）算法的流程
a.从第一个元素起，假定这个元素已经有序
b.从第二个元素起，与已经有序的元素从后向前进行比较
c.如果左边的元素大于取出的元素，则将左边的元素赋值到下一个位置上
继续与有序的元素进行比较
d.如果左边的元素小于取出的元素，则将取出的元素插入到左边元素之后
e.重复以上步骤，直到处理完所有的元素
（2）算法评价
平均时间复杂度o(n^2)，稳定，对样本的有序性比较敏感，但是赋值的次数
比冒泡排序少，所以略优于冒泡排序
/*
* 插入排序算法
*/
#include<stdio.h>
void sort(int arr[],int len){
//1.从第二个数起依次取出，与左边的有序元素依次
//进行比较
int i=0,j=0;
for(i=1;i<len;i++){
int temp=arr[i];
//2.如果左边的元素比取出的元素大，则左边的元素
//右移
for(j=i;j>=1&&arr[j-1]>temp;j--){
arr[j]=arr[j-1];
}
//3.直到左边的元素比取出的小，或者左边已经到达
//边界则插入
//防止自己给自己赋值
if(temp!=arr[j]){
arr[j]=temp;
}
}
}
int main(){
int arr[5]={5,4,3,2,1};
sort(arr,5);
int i=0;
for(i=0;i<5;i++){
printf("%d ",arr[i]);
}
printf("\n");
return 0;
}
4.快速排序
（1）算法的流程
a.选择一个中间元素作为基准值，单独存储起来
b.依次分别使用左边元素和右边元素和基准值比较，将比基准值小的元素放在左边
将比基准值大或者相等的元素放在右边，
c.重复以上过程，直到两边元素的下标重合为止，将基准值放到重合的位置上，此时
比基准值小的元素已经到了基准值左边，比基准值大的元素已经在基准值的右边
d.用递归的方式对基准值左边和右边的元素分别进行分组排序
（2）算法评价
平均时间复杂度o(NlogN)不稳定，如果每次分配都能做到均匀划分，这种情况的排序速度最快
#include<iostream>
using namespace std;
void qsort(int *arr,int low,int high){
int i=low;
int j=high;
if(i>=j)
return;
int tmp=arr[low];
while(i<j){
while(i<j&&arr[j]>tmp)
j--;
arr[i]=arr[j];
while(i<j&&arr[i]<tmp)
i++;
arr[j]=arr[i];
}
arr[i]=tmp;
qsort(arr,low,i-1);
qsort(arr,i+1,high);
}
int main(){
int arr[5]={3,1,2,4,5};
for(int i=0;i<5;i++){
cout<<arr[i]<<",";
}
cout<<endl;
qsort(arr,0,4);
for(int i=0;i<5;i++){
cout<<arr[i]<<",";
}
cout<<endl;
return 0;
}
