g++ -std=c++_在C ++ std库中使用sort（）

冷不防 2023-02-28 06:15 25阅读 0赞

g++ -std=c++

## 介绍 **(****Introduction****)** ##

Hey there! Today we are going to discuss **the sort() function in the std library in C++**.

嘿！ 今天，我们将讨论**C ++中std库中的sort（）函数** 。

For basics, **Sorting** is any process of ordering items systematically. These items could be elements of a sequence or any [data structure][].

对于基础知识， **排序**是系统地对项目进行**排序**的任何过程。 这些项目可以是序列的元素或任何[数据结构][data structure] 。

In **C++**, the standard library provides a pre-defined and ready to use function `sort()` to carry out this sorting operation. So let’s get right into it.

在**C ++中** ，标准库提供了一个预定义的随时可以使用的函数`sort()`来执行此排序操作。 因此，让我们开始吧。

## C ++中的std :: sort（）函数 **(****The std::sort() Function in C++****)** ##

The `std::sort()` function in C++ is a built-in function that is used to sort any form of data structure in a particular order. It is defined in the `algorithm` header file. The `sort()` function prototype is given below.

C ++中的`std::sort()`函数是一个内置函数，用于按特定顺序对任何形式的数据结构进行排序。 它在`algorithm`头文件中定义。 下面给出了`sort()`函数原型。

void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);

Here, the function does not return anything. It just updates the elements/items from the `first` up to the `last` iterables or positions. The **third** parameter(optional) `comp` has to be a function that determines the **order** in which the elements are going to be sorted. When not specified, the sorting takes place in **ascending** order considering it to be the `std::less<int>()` function by default.

在此，该函数不返回任何内容。 它只是从第`first`到`last`可迭代项或位置更新元素/项目。 **第三个**参数（可选） `comp`必须是一个确定元素排序**顺序**的函数。 如果未指定，则默认按`std::less<int>()`函数进行排序， **升序**进行。

The `sort()` function uses a **3** fold hybrid sorting technique named **Introsort**. It is a combination of [Quick Sort][], Heap Sort, and Insertion Sort.

`sort()`函数使用称为**Introsort**的**3**倍混合排序技术。 它是[快速排序][Quick Sort] ，堆排序和插入排序的组合。

## 使用C ++中的sort（）函数对数据进行排序 **(****Sorting data using the sort() Function in C++****)** ##

Now that we have gone through the basics of the `sort()` function, let us use it in our C++ program to sort some data structures(for example **arrays**).

现在，我们已经了解了`sort()`函数的基础知识，让我们在C ++程序中使用它来对一些数据结构（例如**array** ）进行排序。

### 1.升序排列 **(****1. Sorting in Ascending Order****)** ###

As mentioned earlier, by default the `sort()` function sorts a set of items in **ascending** order when `comp` parameter is not mentioned.

如前所述，默认情况下，当未提到`comp`参数时， `sort()`函数将按**升序**对一组项目进行排序。

So for the example below, we have passed just the `first`(starting) and `last`(ending) iterables to sort an array in ascending order.

因此，对于下面的示例，我们仅传递了`first` （开始）和`last` （结束）可迭代对象，以对数组进行升序排序。

#include<iostream>    
    #include<algorithm>
    using namespace std;
    int main()
    {  
        //array initialisation
        int demo[5] = {5, 4, 3, 2, 1};
        
        int len = sizeof(demo)/sizeof(demo[0]);
         
        cout<<"Before sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
         
        std::sort(demo, demo + len);//Sorting demo array
         
        cout<<"\n\nAfter sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
        return 0;
    }

**Output:**

**输出：**

![Sort1][]

Sorting in Ascending Order 升序排列

Here, `demo` is the address of the **first** element and `(demo + len)` is the address of the **last** element of the given array. Hence considering **comp** as `std::less<int>()` function by default, the sort() function sorts the array in **ascending** order.

在这里， `demo`是给定数组的**第一个**元素的地址，而`(demo + len)`是给定数组的**最后一个**元素的地址。 因此，默认情况下考虑将**comp**作为`std::less<int>()`函数，sort（）函数以**升序**对数组进行排序。

**Note:** the `std::less<int>()` function compares two arguments and returns **True** or **False** on the basis of whether the first one is less than the other.

**注意：** `std::less<int>()`函数比较两个参数，并根据第一个参数是否小于另一个参数返回**True**或**False** 。

### 2.降序排列 **(****2. Sorting in Descending Order****)** ###

We can also sort a data structure using the `sort()` function in **descending** order by manipulating its third parameter. Let us see how.

我们还可以通过操作`sort()`函数的第三个参数，以**降序**对数据结构进行`sort()` 。 让我们看看如何。

In the code below we have used the `std::greater<int>()` function which acts exactly the opposite way the `std::less<int>()` function does. It compares its two arguments and returns **True** when the first one is greater than the other. Or else returns **False**.

在下面的代码中，我们使用了`std::greater<int>()`函数，其功能与`std::less<int>()`函数完全相反。 它比较两个参数，并在第一个大于另一个时返回**True** 。 否则返回**False** 。

#include<iostream>    
    #include<algorithm>
    using namespace std;
    int main()
    {  
        //array initialisation
        int demo[5] = {44, 22, 55, 33, 66};
        
        int len = sizeof(demo)/sizeof(demo[0]);
         
        cout<<"Before sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
         
        std::sort(demo, demo + len, greater<int>());//Sorting demo array
         
        cout<<"\n\nAfter sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
        return 0;
    }

We can also use a **lambda function** as the third parameter for the sort() function as shown below.

我们还可以将**lambda函数**用作sort（）函数的第三个参数，如下所示。

#include<iostream>    
    #include<algorithm>
    using namespace std;
    int main()
    {  
        //array initialisation
        int demo[5] = {44, 22, 55, 33, 66};
        
        int len = sizeof(demo)/sizeof(demo[0]);
         
        cout<<"Before sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
         
        std::sort(demo, demo + len, [](int &e1, int &e2){ return e1>e2; });//Sorting demo array
         
        cout<<"\n\nAfter sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
        return 0;
    }

Both the above examples generate the same output as given below. And sort the `demo` array in **descending** order successfully.

上面的两个示例都生成与下面给出的相同的输出。 并成功地**按降序**对`demo`数组进行排序。

**Output:**

**输出：**

![Sort2][]

Sorting in Descending Order 降序排列

### 3.按用户定义的顺序排序 **(****3. Sorting with User-Defined Order****)** ###

The third parameter(**comp**) for the `std::sort()` function can also be a **user-defined** function that defines the order or sorting.

`std::sort()`函数的第三个参数（ **comp** ）也可以是**用户定义的**函数，用于定义顺序或排序。

One should note that this function must return a **boolean** value(`True`/`False`).

应该注意的是，此函数必须返回一个**布尔**值（ `True` / `False` ）。

For example in the code snippet below, we have tried to sort the elements of an array on the basis of the remainders they produce when divided by **10**(using ‘`%`‘ operator).

例如，在下面的代码片段中，我们尝试根据数组元素除以**10**时产生的余数（使用' `%` '运算符）对它们进行排序。

#include<iostream>    
    #include<algorithm>
    using namespace std;
    
    //our function
    bool My_func( int a, int b)
    {	
    	return (a%10)<(b%10);
    }
    
    int main()
    {  
        //array initialisation
        int demo[5] = {18, 45, 34, 92, 21};
        
        int len = sizeof(demo)/sizeof(demo[0]);
         
        cout<<"Before sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
         
        std::sort(demo, demo + len, My_func);//Sorting demo array
         
        cout<<"\n\nAfter sorting array : ";
        for(int i=0; i<len; i++)
        {
            cout<<" "<<demo[i];
        }
        return 0;
    }

**Output:**

**输出：**

![Sort3][]

Sort with User-defined Function 用用户定义的功能排序

As we can see from the above output, the `demo` array has been sorted successfully on the basis of (`element%10`) factor. With the help of our `My_func()` function.

从上面的输出中可以看到， `demo`数组已成功根据（ `element%10` ）因子进行了排序。 借助我们的`My_func()`函数。

## C ++中std :: sort（）的复杂性 **(****Complexity of std::sort() in C++****)** ##

The `sort()` function performs **Nlog(N)** comparisons for sorting N items. And hence for the worst-case scenario, it has an **O(Nlog(N))** complexity.

`sort()`函数执行**Nlog（N）**比较以对N个项目进行排序。 因此，在最坏的情况下，它具有**O（Nlog（N））**复杂度。

## 加起来 **(****Summing Up****)** ##

So that’s it for this one. Today we understood the use and working of the **`sort()`** function in C++ standard library. Hope you had a clear understanding.

就是这样。 今天，我们了解了C ++标准库中**`sort()`**函数的使用和工作方式。 希望您有一个清楚的了解。

Please note that the sort() function can be used for data structures other than arrays too, like [vectors][], etc.. For this tutorial, we have considered arrays for better understanding.

请注意，sort（）函数也可以用于数组以外的数据结构，例如[vector][vectors]等。在本教程中，我们考虑使用数组来更好地理解。

We recommend going through our [C++ Tutorial][C_ Tutorial].

我们建议您阅读我们的[C ++教程][C_ Tutorial] 。

For any further questions, feel free to use the comment below.

如有其他疑问，请随时使用以下评论。

## 参考资料 **(****References****)** ##

*  [std::sort()][std_sort] – C++ Documentation,
    
    [std :: sort（）][std_sort] – C ++文档，
 *  [Standard Template Library (STL) in C++][Standard Template Library _STL_ in C],
    
    [C ++中的标准模板库（STL）][Standard Template Library _STL_ in C] ，
 *  [<algorithm>][algorithm] – C++ algorithm Library.
    
    [<algorithm>][algorithm] – C ++算法库。

> 翻译自: [https://www.journaldev.com/40495/sort-in-c-plus-plus][https_www.journaldev.com_40495_sort-in-c-plus-plus]

g++ -std=c++

[data structure]: https://www.journaldev.com/data-structure-algorithms
[Quick Sort]: https://www.journaldev.com/37033/quicksort-algorithm-in-c-java-python
[Sort1]: /images/20230209/d4f644cd5adc4777b3c4817cdc313a74.png
[Sort2]: /images/20230209/4c42750f465640ef9d9d844e81da57d2.png
[Sort3]: /images/20230209/a3c337dca3f644e383d145f677e2c400.png
[vectors]: https://www.journaldev.com/37678/sorting-a-vector-in-c-plus-plus
[C_ Tutorial]: https://www.journaldev.com/c-plus-plus
[std_sort]: http://www.cplusplus.com/reference/algorithm/sort/
[Standard Template Library _STL_ in C]: https://www.journaldev.com/36489/standard-template-library-in-c-plus-plus
[algorithm]: https://docs.microsoft.com/en-us/cpp/standard-library/algorithm?view=vs-2019
[https_www.journaldev.com_40495_sort-in-c-plus-plus]: https://www.journaldev.com/40495/sort-in-c-plus-plus