10个数冒泡排序流程图_10大排序算法的简洁代码实现

#include <stdio.h>
#include <vector>
#include <algorithm>
#include <unistd.h>
using namespace std;

// 辅助函数，顺序打印vector v中的数据
void Print(vector<int>& v){
    for(int i=0;i<v.size()-1;i++){
        printf("%d-",v[i]);
    }
    printf("%dn",v[v.size()-1]);
}

void bubble_sort(vector<int>& v){
    int n = v.size();
    for(int i=0;i<n-1;i++){ // 对n-1个数据进行冒泡放置
        bool flag = false;  // 该轮中是否还存在逆序对 
        for(int j=0;j<n-i-1;j++){
            if(v[j]>v[j+1]){
                swap(v[j],v[j+1]);
                if(!flag) flag = true;
            }
        }
        if(!flag) break;
    }
}

void insert_sort(vector<int>& v){
    int n = v.size();
    for(int i=1;i<n;i++){ // 要被取出来插入到别处的元素的下标位置：从1~n-1
        int elem = v[i], j=i-1;
        for(j=i-1;j>=0;j--){ // 要比较的元素的id
            if(v[j]>elem) v[j+1] = v[j];
            else {break;}
        }
        v[j+1]=elem;
    }
}

void select_sort(vector<int>& v){
    int n = v.size();
    for(int i=0;i<n;i++){ // 选择最小后的数后要放置的位置
        int idx=i;
        for(int j=i+1;j<n;j++){
            if(v[j]<v[idx]) idx=j;
        }
        swap(v[i],v[idx]);
    }
}

void shell_sort(vector<int>& v){
    int n = v.size();
    int step = n/2;
    while(step>0){
        // 对每组元素进行插入排序；等价于对step及以后的元素进行插入排序
        for(int i=step;i<n;i++){
            int elem=v[i], j=i-step;
            for(j=i-step;j>=0;j-=step){
                if(v[j]>elem) v[j+step] = v[j];
                else {break;}
            }
            v[j+step] = elem;
        }
        step /= 2;
    } 
}

void merge_fn(vector<int>& v, int st, int ed){
    if(st>=ed) return;
    int mid= st + ((ed-st)>>1);
    merge_fn(v, st, mid);
    merge_fn(v, mid+1, ed);
    // 合并排序后的结果，先申请一个和v[st,ed]等大的临时数组
    vector<int> tmp_v(ed-st+1);
    int i=st, j=mid+1, k=0;
    while(i<=mid || j<=ed){
        tmp_v[k++] = ((i<=mid && v[i]<v[j])||(j>ed))? v[i++] : v[j++];
    }
    // 重新赋值
    for(int i=st;i<=ed;i++) v[i]=tmp_v[i-st];
}

void merge_sort(vector<int>& v){
    merge_fn(v, 0, v.size()-1);
}

void quick_sort_fn(vector<int>& v, int l, int r){
    // 递归出口
    if(l>=r) return;
    
    // 先遍历一次让pivot就位
    int pivot = v[r];
    int i=l, j=l; // i指向第一个大于等于pivot元素的位置（其实就是最后pivot要放置的位置）
                  // j用于遍历
    for(;j<r;j++){
        if(v[j]<pivot){
            swap(v[i],v[j]);
            i++; // 从而保持i往右都是大于等于pivot的元素
        }
    }
    swap(v[r],v[i]); // 最终pivot元素就位，根据pivot被分成了两部分

    // 然后再递归解决两边
    quick_sort_fn(v, l, i-1);
    quick_sort_fn(v, i+1, r);
}

void quick_sort(vector<int>& v){
    quick_sort_fn(v, 0, v.size()-1);
}

void count_sort(vector<int>& v){
    // 1. 产生计数表
    // 1.1 找出最大值
    int max_num = v[0];
    for(int i=0;i<v.size();i++) max_num = max(max_num, v[i]);
    // 1.2 生成计数表
    vector<int> count_table(max_num+1, 0);
    for(int i=0;i<v.size();i++) count_table[v[i]]++;
    for(int i=1;i<count_table.size();i++) count_table[i] += count_table[i-1];
    // 2. 从后往前遍历v，就位在临时数组中
    vector<int> tmp_v(v.size());
    for(int i=v.size()-1;i>=0;i--) tmp_v[--count_table[v[i]]]=v[i];

    // 3. 将tmp_v赋值给v
    for(int i=0;i<tmp_v.size();i++) v[i]=tmp_v[i];
}

void down_adjust(vector<int>& v, int n, int idx){
    int max_idx = idx;
    while(true){
        int tmp_max_idx = max_idx;
        int lch_idx = 2*max_idx+1, rch_idx = 2*max_idx+2;
        if(lch_idx<n) max_idx = v[lch_idx]>v[max_idx]? lch_idx:max_idx;
        if(rch_idx<n) max_idx = v[rch_idx]>v[max_idx]? rch_idx:max_idx;
        if(max_idx==tmp_max_idx) break;
    }
    swap(v[max_idx],v[idx]);
    return;
}

void build_big_heap(vector<int>& v){
    // 从下标是(n-1)/2的元素到0的元素进行下调
    int n=v.size();
    for(int i=(n-1)/2;i>=0;i--){
        down_adjust(v,n,i);
    }
}

void heap_sort(vector<int>& v){
    // 首先是建堆过程，O(n)；然后是排序过程
    // 由于排序过程我们希望是原地排序，因此要从最后开始就位元素；因此建立大顶堆。
    build_big_heap(v); // 采用从下往上的建堆方式
    // 每次把堆顶元素换入最后，然后对堆顶元素进行下调
    int n = v.size();
    for(int i=n-1;i>0;--i){
        swap(v[0],v[i]);
        down_adjust(v,i,0); // 总个数要变成i，不能再是n
    }
}

int main(){
    int a[6]={5,3,6,2,1,4};
    vector<int> v(a,a+6);
    Print(v); // 打印排序前的算法
    // 排序算法
    // bubble_sort(v);
    // insert_sort(v);
    // select_sort(v);
    // shell_sort(v);
    // merge_sort(v);
    // quick_sort(v);
    // count_sort(v);
    // heap_sort(v);
    Print(v);  // 打印排序后的算法
    return 0;

}