经典排序算法 C++代码实现

排序算法理论

十种经典排序算法
归并排序
快排
堆排

C++代码实现

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;

void swap03(int & a,int & b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    vector<int> arr = {2,3,8,99,55,64,28,37,11};
    bubbleSort(arr);
    selectionSort(arr);
    insertionSort(arr);
    shellSort(arr);
    mergeSort(arr);
    quickSort(arr);
    heapSort(arr);
    countingSort(arr);
    bucketSort(arr);
    radixSort(arr);
    for (auto s : arr) {
        cout<<s<<" ";
    }
    cout<<endl;
    return 0;
}

冒泡排序

// 冒泡排序 将小的数往前“冒泡”
void bubbleSort(vector<int>& arr) {
    int len = arr.size();
    for (int i = 0; i<len; ++i) {
        for (int j = i; j<len; ++j) {
            if (arr[i] > arr[j]) {
                swap03(arr[i],arr[j]);
            }
        }
    }
}

选择排序

// 选择排序  从未排序元素中找到小的数，放到已排序序列的末尾
void selectionSort(vector<int>& arr) {
    int len = arr.size();
    for (int i = 0; i<len; ++i) {
        int index = i, min = arr[i];
        for (int j = i; j<len; ++j) {
            if (min > arr[j]) {
                min = arr[j];
                index = j;
            }
        }
        swap03(arr[index], arr[i]);
    }
}

插入排序

// 插入排序    对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
void insertionSort(vector<int>& arr) {
    int len = arr.size();
    for (int i = 0; i<len; ++i) {
        int temp = arr[i], j = i-1;
        while (j>=0 && arr[j]>temp) {  // 在已排序序列中从后向前扫描
            arr[j+1] = arr[j];
            --j;
        }
        arr[j+1] = temp;  // 找到相应位置并插入
    }
}

希尔排序

// 希尔排序    与插入排序的不同之处在于，它会优先比较距离较远的元素
void shellSort(vector<int>& arr) {
    int len = arr.size();
    int inc_seq = 0;
    for (inc_seq = len/2; inc_seq>0; inc_seq = inc_seq/2) {  // 构建一个增量序列
        for (int i = inc_seq; i<len; ++i) {
            int temp = arr[i], j = i-inc_seq;
            while (j>=0 && arr[j]>temp) {
                arr[j+inc_seq] = arr[j];
                j -= inc_seq;
            }
            arr[j+inc_seq] = temp;
        }
    }
}

归并排序

// 归并排序   把长度为n的输入序列分成两个长度为n/2的子序列；并对子序列分别采用归并排序
void merge(vector<int>& arr, int left, int right) {
    int mid = (left+right) / 2;
    vector<int> temp;  // 暂存合并后的完全有序的序列
    int i = left, j = mid+1;
    while (i<=mid && j<=right) {
        if (arr[i]<arr[j]) {
            temp.push_back(arr[i++]);
        } else {
            temp.push_back(arr[j++]);
        }
    }
    while (i<=mid) {
        temp.push_back(arr[i++]);
    }
    while (j<=right) {
        temp.push_back(arr[j++]);
    }
    int t = 0;
    while (left<=right) {
        arr[left++] = temp[t++];
    }    
}

void mergeSort (vector<int>& arr, int left, int right) {
    if (left<right) {
        int mid = (left+right) / 2;
        mergeSort(arr, left, mid);  // 序列分半；并对子序列采用归并排序
        mergeSort(arr, mid+1, right);
        merge(arr, left, right);  // 将两个排序好的子序列合并成一个最终的排序序列
    }
}

void mergeSort(vector<int>& arr) {
    int len = arr.size();
    mergeSort(arr, 0, len-1);
}

快速排序

// 快速排序  使用分治法来把一个串分为两个子串，一子串比另一串小
void quickSort(vector<int>& arr, int left, int right) {
    if (left < right) {  // 边界条件
        // swap03(arr[left], arr[(left+right)/2]);// 以中间的数作为基准数
        int pivot = arr[left];  //先从数列中取出一个数作为基准数
        int i = left, j = right;
        while (i < j) {
            while (i<j && pivot <= arr[j]) {  // 分区过程，将比基准数大的数全放到它的右边
                j--;
            }
            if (i<j) arr[i++] = arr[j];
            
            while (i<j && pivot >= arr[i]) {  // 小于基准数的数全放到它的左边
                i++;
            }
            if (i<j) arr[j--] = arr[i];
        }
        arr[i] = pivot;
        
        quickSort(arr, left, i-1);  // 再对左右区间重复第二步，直到各区间只有一个数
        quickSort(arr, i+1, right);
    }
}

void quickSort(vector<int>& arr) {
    int len = arr.size();
    quickSort(arr, 0, len-1);
}

堆排序

// 堆排序    利用堆这种数据结构所设计的排序算法
void adjustHeap(vector<int>& arr, int i, int len_heap) {
    // 调整（大顶）堆,（仅是调整过程，建立在大顶堆已构建的基础上）
    int temp = arr[i];
    for (int k = 2*i+1; k<len_heap; k = 2*i+1) {
        if (k+1<len_heap && arr[k]<arr[k+1]) {
            k++;
        }
        if (temp < arr[k]) {  // （大顶）
            arr[i] = arr[k];
            i = k;
        } else break;
    }
    arr[i] = temp;
}

void heapSort(vector<int>& arr) {
    int len = arr.size();
    // 构建（大顶）堆
    for (int i = len/2-1; i>-1; --i) {  // 从第一个非叶子结点从下至上，从右至左调整结构
        adjustHeap(arr, i, len);
    }
    
    for (int i = len-1; i>0; --i) {
        swap03(arr[0], arr[i]);  // 将堆顶元素与末尾元素进行交换
        adjustHeap(arr, 0, i);  // 重新对堆进行调整
    }
}

计数排序

//计数排序   其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中
void countingSort(vector<int>& arr, int min, int max) {
    vector<int> temp(max-min+1, 0);
    int len = arr.size();
    for (int i = 0; i<len; ++i) {  // 统计数组中每个值出现的次数
        temp[arr[i]-min]++;
    }
    int t = 0;
    for (int i = 0; i<len; ++i) {
        while (temp[t]==0) t++;
        arr[i] = min + t;
        temp[t]--;
    }
}

void countingSort(vector<int>& arr) {
    int len = arr.size();
    int max = arr[0], min = arr[0];
    for (int i = 0; i<len; ++i) {
        if (max < arr[i]) max = arr[i];
        if (min > arr[i]) min = arr[i];
    }
    countingSort(arr, min, max);  // 计数排序要求输入的数据必须是有确定范围的整数
}

桶排序

//桶排序   计数排序的升级版。它利用了函数的映射关系，效率的关键就在于这个映射函数
void bucketSort(vector<int>& arr) {
    int len = arr.size();
    int max = arr[0], min = arr[0];
    for (int i = 0; i<len; ++i) {
        if (max < arr[i]) max = arr[i];
        if (min > arr[i]) min = arr[i];
    }
    
    int DEFAULT_BUCKET_SIZE = 5;  // 设置桶的默认容量为5
    int bucket_count = (max-min) / DEFAULT_BUCKET_SIZE + 1;
    vector<vector<int>> temp(bucket_count);
    for (int i = 0; i<len; ++i) {  // 利用映射函数将数据分配到各个桶中
        temp[(arr[i]-min)/DEFAULT_BUCKET_SIZE].push_back(arr[i]);
    }
    
    int t = 0;
    for (int i = 0; i<bucket_count; ++i) {
        insertionSort(temp[i]);  // 对每个桶进行排序，这里使用了插入排序
        for (int j = 0; j<temp[i].size(); ++j) {
            arr[t++] = temp[i][j];
        }
    }
}

基数排序

//基数排序   按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位
void radixSort(vector<int>& arr) {
    int len = arr.size();
    int max = arr[0], num_radix = 1;
    for (int i = 0; i<len; ++i) {
        if (max < arr[i]) max = arr[i];
    }
    while (max/10) {
        max = max / 10;
        num_radix++;  // 取得数组中的最大数，并取得位数
    }
    
    int mod = 10,dev = 1;
    for (int i = 1; i<=num_radix; ++i, mod*=10, dev*=10) {
        vector<vector<int>> arr_radix(10);
        for (int j = 0; j<len; ++j) {
            arr_radix[arr[j]%mod/dev].push_back(arr[j]);  // 从最低位开始,按每个位组成radix数组
        }
        
        int pos = 0;
        for (int j = 0; j<10; ++j) {
            for (int k = 0; k<arr_radix[j].size(); ++k) {
                arr[pos++] = arr_radix[j][k];  // 类似计数排序
            }
        }
    }
}