[温习C/C++] 0x03-sort排序

系列文章目录

系列文章目录
[温习C/C++]0x00-STL标准模板库概述
[温习C/C++]0x01-STL泛型算法-持续更新长文版
[温习C/C++]0x03-sort排序

---

---

更新日志

日期	变更内容
2024-09-13	完成C++ sort函数章节和C语言qsort章节内容

• 计划
  接下来补充刷题。

C++ sort函数

头文件

#include <algorithm>
或者
#include <bits/stdc++.h>

原型

default (1)	
template <class RandomAccessIterator>  void sort (RandomAccessIterator first, RandomAccessIterator last);
custom (2)	
template <class RandomAccessIterator, class Compare>  void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

1. sort(start, end);
   排序区间收尾指针， 表示参与排序的元素范围 ：[first,last) ， 排序规则不填， 默认升序排序。

2. sort(start, end, comp);
comp就是一个函数或者是一个重载操作符的结构体，通过comp自定义排序规则。

---

3. 官方栗子

// sort algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::sort
#include <vector>       // std::vector

bool myfunction (int i,int j) { return (i<j); }

struct myclass {
  bool operator() (int i,int j) { return (i<j);}
} myobject;

int main () {
  int myints[] = {32,71,12,45,26,80,53,33};
  std::vector<int> myvector (myints, myints+8);               // 32 71 12 45 26 80 53 33

  // using default comparison (operator <):
  std::sort (myvector.begin(), myvector.begin()+4);           //(12 32 45 71)26 80 53 33

  // using function as comp
  std::sort (myvector.begin()+4, myvector.end(), myfunction); // 12 32 45 71(26 33 53 80)

  // using object as comp
  std::sort (myvector.begin(), myvector.end(), myobject);     //(12 26 32 33 45 53 71 80)

  // print out content:
  std::cout << "myvector contains:";
  for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}



Output:
myvector contains: 12 26 32 33 45 53 71 80

sort函数应用

普通的int类型数组

    int data[] = {5, 4, 3, 6};
    int len = sizeof(data) / sizeof(data[0]);
    std::sort(data, data + len);
    for (auto x : data) {
        std::cout << x << " ";
    }

Output:
3 4 5 6

STL标准库自定义排序

vector向量类模板

    vector<int> vec1 {1, 3, 5, 7, 2};
    std::sort(vec1.begin(), vec1.end());
    for (auto x : vec1) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    std::vector<int> vec2 = {1, 3, 5, 7, 2};
    std::sort(vec2.begin(), vec2.end(), [](int x, int y)->bool {
        return x > y;
    });
    for (auto x : vec2) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

Output:
1 2 3 5 7 
7 5 3 2 1

是一个捕获列表为空，接受两个int类型参数x和y，并返回一个bool类型值的表达式。它通过比较x和y的大小，如果x大于y则返回true，否则返回false。

std::sort默认需要一个返回true表示第一个参数应该在第二个参数之前的比较函数。由于这里的比较函数实际上是在说“如果x大于y，则x应该在y之前”，所以排序结果将是一个降序序列。

---

string字符串

通过ASCII值比较大小

    string str1 = "afagjkagjkdg";
    string str2 = "ABCcba321456";
    // 默认升序
    std::sort(str1.begin(), str1.end());

    // lambda表达式自定义比较规则
    // 返回true不交换， false交换
    std::sort(str2.begin(), str2.end(), [](int x, int y)->bool {
       return x > y;
    });
    std::cout << "str1 :" << str1 << std::endl;
    std::cout << "str2 :" << str2 << std::endl;

Output:
str1 :aaadfgggjjkk
str2 :cbaCBA654321

struct结构体

• 定义结构体

struct Data {
    int a;
    int b;
    int c;
    Data() {

    }
    Data(int x, int y, int z) : a(x), b(y), c(z) {

    }
};

• 排序栗子

    int data_size = 8;
    Data arr[data_size];
    arr[0] = Data(1, 0, 3);
    arr[1] = Data(3, 2, 1);
    arr[2] = Data(4, 4, 0);
    arr[3] = Data(5, 2, 2);
    arr[4] = Data(2, 6, 5);
    arr[5] = Data(2, 8, 5);
    arr[6] = Data(1, 0, 5);
    arr[7] = Data(3, 2, 5);

    std::sort(arr, arr + data_size, [](Data d1, Data d2) ->bool {
        if (d1.a == d2.a) {
            if (d1.b == d2.b) {
                return d1.c > d2.c; // 根据c大小降序
            }
            return d1.b > d2.b; // 根据b大小降序
        }
        return d1.a < d2.a; // 根据a大小升序
    });

    for (auto x : arr) {
        cout << "  " << x.a << " " << x.b << " " << x.c << std::endl;
    }

Output:
  1 0 5
  1 0 3
  2 8 5
  2 6 5
  3 2 5
  3 2 1
  4 4 0
  5 2 2

本例中优先使用a升序排序；如果a相同，按照b降序排序；如果a、b相同再按照c降序排序。

C语言qsort

qsort函数C语言编译器函数库自带的快速排序函数。

头文件

qsort函数包含在C 标准库 - <stdlib.h>中。

函数原型:

void qsort( void *ptr, size_t count, size_t size,
            int (*comp)(const void *, const void *) );

结构体排序

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct Node {
    int x;
    int y;
};

//按照x从小到大排序，当x相等时按y从大到小排序
int Comp(const void* p1,const void* p2) {
    struct Node* n1 = (struct Node*)p1;
    struct Node* n2 = (struct Node*)p2;
    if(n1->x != n2->x) {
        return n1->x - n2->x;
    }
    return n2->y - n1->y;
};

int main(int argc, char **argv) {
    size_t size = 5;
    struct Node* nodes = (struct Node*) malloc(size * sizeof (struct Node));
    if (nodes == NULL) {
        return -1;
    }
    (void)memset(nodes, 0, size * sizeof(struct Node));
    for (int i = 0; i < size; ++i) {
        struct Node* tmp = nodes + i;
        tmp->x = i;
        tmp->y = i * 3;
    }
    // 排序
    qsort(nodes, size, sizeof(struct Node), Comp);
    for (int i = 0; i < size; ++i) {
        struct Node* tmp = nodes + i;
        printf("x : %d , y: %d \n", tmp->x, tmp->y);
    }
    free(nodes);
    return 0;
}

Output:
x : 0 , y: 0 
x : 1 , y: 3 
x : 2 , y: 6 
x : 3 , y: 9 
x : 4 , y: 12