排序方法

 

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <list>
#include <algorithm>
#include <set>
#include <stack>
using namespace std;


//冒泡排序
template <typename T> void bubbleSort(T arr[], int low, int high)
{
    for (int i = low; i < high; i++) {
        for (int j = low; j < high - i; j++) {
            if (arr[j] > arr[j + 1])
                swap(arr[j], arr[j + 1]);
        }
    }
}

//快速排序
template <typename T> void quickSort(T arr[], int low, int high)
{
    if (high <= low) return;
    int i = low;
    int j = high + 1;
    while (true) {
        //从左向右找比key大的值
        while (i < high && arr[++i] < arr[low]);
        //从右向左找比key小的值
        while (j > low && arr[--j] > arr[low]);
        //到了中间值，退出
        if (i >= j) break;
        //交换i,j对应的值
        swap(arr[i], arr[j]);
    }
    //中枢值与j对应值交换
    swap(arr[low], arr[j]);
    QuickSort(arr, low, j - 1);
    QuickSort(arr, j + 1, high);
}

//插入排序
template <typename T> void insertSort(T arr[], int low, int high)
{
    T tmp;
    int i;
    int j;
    for (i = low; i <= high; i++) {
        tmp = arr[i];//待排序元素
        //j为有序序列的最后一个元素，即待排序元素的前一个元素
        //待排元素小于有序序列的最后一个元素时，向前插入
        for (j = i - 1; j >= 0 && arr[j] > tmp;j--) {
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = tmp;
    }
}

//希尔排序
template <typename T> void shellSort(T arr[], int low, int high){
    //vector<int> result = list;
    //int n = result.size();
    int j;
    for (int gap = high + 1 >> 1; gap > 0; gap >>= 1){
        for (int i = low + gap; i < high + 1; i++){
            int tmp = arr[i];
            for (j = i - gap; j >= low && arr[j] > tmp; j -= gap) {
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = tmp;
        }
    }
}

//归并排序
//https://blog.youkuaiyun.com/m0_38068229/article/details/81262282
template <typename T> void merge(T arr[], int l, int mid, int r) {
    T *tmp = new T[r - l + 1];//辅助数组
    int i = 0;
    int lIndex = l;
    int rIndex = mid + 1;
    while (lIndex <= mid && rIndex <= r) {
        tmp[i++] = arr[lIndex] < arr[rIndex] ? arr[lIndex++]:arr[rIndex++];
    }
    //左边和右边肯定有一边到头了，不可能同时，因为每次只移动一边
    while (lIndex <= mid) {
        tmp[i++] = arr[lIndex++];
    }
    while (rIndex <= r) {
        tmp[i++] = arr[rIndex++];
    }
    //将排好序的辅助数组赋值给原始数组，不需要返回值
    for (i = 0; i < r - l + 1; i++) {
        arr[l+i] = tmp[i];
    }
    free(tmp);
    tmp = nullptr;
}

//递归
template <typename T> void mergeSort(T arr[], int l, int r) {
    if (l >= r) {
        return;
    }
    int mid = (l + r) >> 1;
    //左半部分归并排序
    mergeSort(arr, l, mid);
    //右半部分归并排序
    mergeSort(arr, mid + 1, r);
    //左右部分归并
    merge(arr, l, mid, r);

}

int main()
{
    //int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
    //double a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
    //double a[] = {3,4,1,2,5};
    double a[] = {20, 6, 12, 7, 10};

//QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);//这里原文第三个参数要减1否则内存越界
//BubbleSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);//这里原文第三个参数要减1否则内存越界
//InsertSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);//这里原文第三个参数要减1否则内存越界
//ShellSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);//这里原文第三个参数要减1否则内存越界
mergeSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);//这里原文第三个参数要减1否则内存越界

for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++) {
    cout << a[i] << " ";
}

return 0;

}

 

 

有序数据结构的初始化

#include<set>

//自定义set的key
typedef struct OlympicKey
{
    uint64_t gold;
    uint64_t silver;
    uint64_t bronze;
    string nation;

    //*
    //方法一
    bool operator>(const OlympicKey &k2) const {
        //大顶堆
        cout <<__LINE__<<endl;
        if(gold > k2.gold) return true;
        if(gold < k2.gold) return false;
        return true;
    }

    bool operator<(const OlympicKey &k2) const {
        //小顶堆
        cout <<__LINE__<<endl;
        if(gold < k2.gold) return true;
        if(gold > k2.gold) return false;
        return true;
    }
     //*/

    /*
    //方法一点五
    friend bool operator>(const OlympicKey &k1, const OlympicKey &k2) {
        //大顶堆
        cout <<__LINE__<<endl;
        if(k1.gold > k2.gold) return true;
        if(k1.gold < k2.gold) return false;
        return true;
    }

    friend bool operator<(const OlympicKey &k1, const OlympicKey &k2) {
        //小顶堆
        cout <<__LINE__<<endl;
        if(k1.gold < k2.gold) return true;
        if(k1.gold > k2.gold) return false;
        return true;
    }
     //*/

} OlympicKey;


/*
//方法二
bool operator>(const OlympicKey &k1, const OlympicKey &k2) {
    //大顶堆
    cout <<__LINE__<<endl;
    if(k1.gold > k2.gold) return true;
    if(k1.gold < k2.gold) return false;
    return true;
}

bool operator<(const OlympicKey &k1, const OlympicKey &k2) {
    //小顶堆
    cout <<__LINE__<<endl;
    if(k1.gold < k2.gold) return true;
    if(k1.gold > k2.gold) return false;
    return true;
}
 //*/


int main()
{

    //方法一//方法二
    set<OlympicKey, greater<OlympicKey> > OlympicSet;
    //set<OlympicKey, greater<OlympicKey> > OlympicSet;


    //方法三
    /*
    struct cmp_key
    {
        bool operator()(const OlympicKey &k1, const OlympicKey &k2) const
        {
            if(k1.gold > k2.gold) return true;
            if(k1.gold < k2.gold) return false;
            return true;
        };
    };
    set<OlympicKey, cmp_key> OlympicSet;
    //*/

    /*
    //第四种方法，尚未调通
    auto cmp = [&](const OlympicKey k1, const OlympicKey k2) -> bool{
        //大顶堆
        //cout <<__LINE__<<endl;
        if(k1.gold > k2.gold) return true;
        if(k1.gold < k2.gold) return false;
        return true;
    };

    set<OlympicKey, decltype(cmp) > OlympicSet;
     //*/


    int num = 2;

    OlympicKey key;
    key.gold = 33;
    key.silver = 28;
    key.bronze = 34;
    key.nation = "China";
    OlympicSet.insert(key);

    OlympicKey key2;
    key2.gold = 32;
    key2.silver = 28;
    key2.bronze = 34;
    key2.nation = "Russia";
    OlympicSet.insert(key2);

    // please define the C++ output here. For example:cout<<____<<endl;
    for (auto &it: OlympicSet) {
        cout << it.nation << endl;
    }
    return 0;
}

https://blog.youkuaiyun.com/qq_32541007/article/details/71057282

https://www.cnblogs.com/lengbingshy/p/3491192.html

 

数组排序

https://blog.youkuaiyun.com/hust_bochu_xuchao/article/details/78950370

https://blog.youkuaiyun.com/m0_37433111/article/details/108524173

 

 

使用sort函数进行排序

struct building
{
    int left;
    int right;
    int height;
};

//升序
bool asc (building &b1, building &b2) {
    if (b1.left < b2.left) return true;
    if (b1.left > b2.left) return false;
    if (b1.height > b2.height) return true;
    if (b1.height < b2.height) return false;
    if (b1.right < b2.right) return true;
    if (b1.right > b2.right) return false;
    return false;
}

//sort(bb.begin(), bb.end(), asc);