关于十大排序算法的讲解【建议用visio画图动态演示一下】

1.冒泡排序:从前往后两两元素比较，把最大的 元素放后面

#include<algorithm>
#include<iostream>
using namespace std;
void bubblesort(int arr[],int n){
    for(int i=n-1;i>0;i--){
        for(int j=0;j<i;j++){
             if(arr[j]>arr[j+1])
             swap(arr[j],arr[j+1]);
        }
    }
}
int main(){
    int arr[]={2,3,4,5,6,9,8,7};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubblesort(arr,n);
    for(int i=0;i<n;i++){
        cout<<arr[i]<<" ";
    }
}

运行结果：

2.基数排序：

//基数排序就是根据数字的每一位来排序，不断更新位数实现数字的排序
#include<iostream>
#include<algorithm>
using namespace std;
void basesort(int arr[],int n){
     int max_ele=*max_element(arr,arr+n);
     int count[10];//设置数组统计各种类型数字出现位数
     int output[n];
     for(int exp=1;max_ele/exp<1;exp*=10)
     {
         //统计位数
         for(int i=0;i<n;i++){
            count[(arr[i]/exp)%10]++;
         }
         //利用前缀和确定放入元素位置
         for(int j=1;j<n;j++){
            count[j]+=count[j-1];
         }
         
         for(int m = n-1;m>0;m--){ //只能从大到小遍历
            output[count[(arr[m]/exp)%10]-1]=arr[m];
            count[(arr[m]/exp)%10]--;
         }


     }
}
int main(){
    int arr[]={2,3,4,5,89,98};
    int n=sizeof(arr)/sizeof(arr[0]);
    basesort(arr,n);
    for(int i=0;i<n;i++){
        cout << arr[i] << " ";
    }
}

3.计数排序：

//统计每个元素出现的次数作为序号，利用前缀和让数组有序
#include<iostream>
#include<algorithm>
using namespace std;
void count_sort(int arr[],int n){
    //确定最大数
    int max_ele=*max_element(arr,arr+n);
    // int max_bit;
    // while(max_ele>0)
    // {
    //     max_ele/=10;
    //     max_bit++;
    // }
    //统计前缀和
    int  count[max_ele+1]={0};
    int  output[n];
    for(int i=0;i<n;i++){
        count[arr[i]]++;
    }
    for(int i=1;i<=max_ele;i++){
        count[i]+=count[i-1];
    }
    //复制一个数组，把这些元素放到本该属于的位置
    for(int i=0;i<n;i++){
        output[count[arr[i]]-1]=arr[i];
    }
    for(int j=0;j<n;j++){
        arr[j]=output[j];
    }
}
int main(){
    int arr[]={3,4,5,6,8,9,7};
    int n=sizeof(arr)/sizeof(arr[0]);
    count_sort(arr,n);
    for(int m=0;m<n;m++){
        cout<<arr[m]<<" ";
    }
}

4.桶排序：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void bucketsort(float arr[],int n){
     vector<float>  buckets[n];
     //将元素分到桶里面
     for(int m=0;m<n;m++){
         //确定桶的序号
         int  bucketindex=n  * arr[m];
         buckets[bucketindex].push_back(arr[m]);
     }
     //桶内部排序 
     for(int i=0;i<n;i++){
        sort(buckets[i].begin(),buckets[i].end());
     }
     //排序后的元素放到更新的数组里面
     int index=0;
     for(int i=0;i<n;i++){
        for(float value: buckets[i])  //有多个值
        {
            arr[index++]=value;
        }
     }

}
int main(){
    float  arr[]={0.9,0.8,0.7,0.3,0.5,0.6};
    int n =sizeof(arr)/sizeof(arr[0]);
    bucketsort(arr,n);
    for(int m = 0; m< n;m++){
        cout << arr[m] << " ";
    }
}

5.归并排序：

//利用二分的思想不断进行左边和右边递归地二分排序，(始终左边的元素小于右边)直至整个数组有序
#include<iostream>
#include<algorithm>
using namespace std;

void partition(int arr[],int low,int mid,int high){
    int n1=mid-low+1,n2=high-mid;
    int output[n1+n2];
    int i=low,j=mid+1;
    int index=low;
    while(i<=mid&&j<=high){  //不能用for循环，for循环我们无法得出什么时候其中一个所有所有元素比较好，（只有小的被拿走）。
            if(arr[i]>arr[j]){
                   output[index++]=arr[j];
                   j++;
            }else{
                output[index++]=arr[i];
                i++;
            }
    }
    while(i<=mid)      {
        output[index++]=arr[i++];
    }
    while(j<=high){
        output[index++]=arr[j++];
    }
    for(int m=low;m<=high;m++){
        arr[m]=output[m];
    }
                   
    }

void mergesort(int arr[],int low ,int high){
 
    if(low<high){
        int mid =low+(high-low)/2;
        mergesort(arr,low,mid);
        mergesort(arr,mid+1,high);
        partition(arr,low,mid,high);
    }
       
}
int main(){
    int arr[]={29,385,45,66,87};
    int n = sizeof(arr)/sizeof(arr[0]);
    mergesort(arr,0,n-1);
    for(int m = 0; m<n;m++){
        cout<<arr[m]<<" ";
    }
}

6.堆排序：

#include<iostream>
#include<algorithm>
using namespace std;
//通过自下而上对非叶子节点遍历.

void heapinit(int arr[],int i,int n){
     int  max=i;
     int  max_l=2*i+1;
     int  max_r=2*i+2;
     if(max_l<n&&arr[max_l]>arr[max]){
        max=max_l;
     }
     if(max_r<n&&arr[max_r]>arr[max]){
        max=max_r;
     }
     if(max!=i){
        swap(arr[i],arr[max]);
        heapinit(arr,max,n);//根据根顶点元素继续向底层调整堆
     }


}
void heapsort(int arr[],int n){
     for(int i=n/2-1;i>=0;i--){
        heapinit(arr,i,n);
     }
  
     for(int i=n-1;i>=1;i--){
        swap(arr[i],arr[0]);
        //调整堆
        heapinit(arr,0,i);
     }
}
    
int main(){
    int arr[]={3,4,5,8,7,9,1};
    int n=sizeof(arr)/sizeof(arr[0]);
    heapsort(arr,n);
    for(int m = 0; m<n;m++){
        cout<<arr[m]<<" ";
    }
}

7.插入排序：

//第一个元素有序，从第二个元素开始插入保证前面有序，比后续元素大的往后移，小的后面插入该元素直到整个数组有序
#include<iostream>
#include<algorithm>
using namespace std;
void insert_sort(int arr[],int n){

      for(int i=1;i<n;i++){ 
          for(int j=i-1;j>=0;j--){
            if(arr[j]>arr[i]){
                arr[j+1]=arr[j];
            }else{
                swap(arr[++j],arr[i]);
                break;
            }
          }
      }
}
int main(){
    int arr[] = {3,4,5,6,7,8,0,9};
    int n=sizeof(arr)/sizeof(arr[0]);
    insert_sort(arr,n);
    for(int m=0;m<n;m++){
        cout<<arr[m]<<" ";
    }
    
}

8.希尔排序：

//增量排序
#include<iostream>
#include<algorithm>
using namespace std;
void shell_sort(int arr[],int n){
      for(int gap=n/2;gap>=1;gap/=2){
          for(int i =gap;i<n;i++){
              if(arr[i-gap]>arr[i]){
                swap(arr[i-gap],arr[i]);
              }
          }
      }
}
int main(){
    int arr[]={4,5,6,7,8,9,0,12};
    int n=sizeof(arr)/sizeof(arr[0]);
    shell_sort(arr,n);
    for(int m=0;m<n;m++){
        cout<<arr[m]<<" ";
    }
}

9.快速排序：

//快排以最后一个元素作为基准值通过交换来划分，左边要小于右边,递归地进行划分;每次划分的pivot值不一样
#include<iostream>
#include<algorithm>
using namespace std;
void quicksort(int arr[],int low,int high){
    if(low<high){
    int pivot = arr[high];
    int   i = low-1;
    for(int j=low;j<high;j++){
        if(arr[j]<pivot){
            swap(arr[j],arr[++i]);
        }
    }
    swap(arr[++i],arr[high]);  //划分
    
    quicksort(arr,low,i-1);
    quicksort(arr,i+1,high);
    }


}
int main(){
    int arr[]={3,4,5,6,9,8,10};
    int n = sizeof(arr)/sizeof(arr[0]);
    quicksort(arr,0,n-1);
    for(int m=0;m<n;m++){
        cout<<arr[m]<<" ";
    }
}

10.选择排序：

//从待排序的序列中选择最小的元素放到前面直到整个数组有序
#include<iostream>
#include<algorithm>
using namespace std;
void select_sort(int arr[],int n){
    for(int i=0;i<n-1;i++)
    { 
        int min_index=i;
        for(int j=i+1;j<n;j++)  {
            if(arr[j]<arr[i]){
                swap(arr[j],arr[i]);
            }
        }
    }
}
int main(){
    int arr[]={3,4,5,6,7,8,9,12,15};
    int n=sizeof(arr)/sizeof(arr[0]);
    select_sort(arr,n);
    for(int m=0;m<n;m++){
        cout<<arr[m]<<" ";
    }
}