【C++11算法】is_sorted、is_sorted_until

已于 2024-06-15 19:57:20 修改
阅读量1.1k 收藏 4
点赞数 2
分类专栏： C++大合集 文章标签： c++ 算法 开发语言 c语言 软件工程 c++ 20 c++23
于 2023-10-08 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62599305/article/details/132359115
版权

文章目录

  • 前言
    • 一、is_sorted函数
    • 1.1 is_sorted是什么
    • 1.2 函数原型
    • 1.3 示例代码1
    • 二、is_sorted_until
    • 2.1 is_sorted_until是什么？
    • 2.2 函数原型
    • 2.3示例代码2
  • 总结

前言

在C++11标准中，引入了一系列强大的算法函数，用于处理容器和序列。这些算法函数提供了丰富的功能，可以帮助开发人员高效地操作数据。本文将重点介绍is_sorted和is_sorted_until这两个算法函数。is_sorted用于判断序列是否已经按指定排序准则排序好了，而is_sorted_until则用于查找序列中首个无序元素的位置。

一、is_sorted函数

1.1 is_sorted是什么

is_sorted函数用于判断一个序列是否已经按照指定的排序准则排序好了。

1.2 函数原型

下面是is_sorted函数的函数原型：

template<class ForwardIt>
bool
了解本专栏 订阅专栏 解锁全文 超级会员免费看
C++ STL非更易型算法 检验是否排序is_sorted、is_sorted_until使用方法
qq_44800780的博客
12-25 384
检验[_First,_Last)区间内的元素是否已经排序，使用operator<比较元素 检验[_First,_Last)区间内的元素是否已经排序，使用_Pred(elem1,elem2)比较元素,如果elem1小于elem2返回true 检验[_First,_Last)区间内第一个破坏排序的元素，如果没有这样的元素返回end,使用operator<比较元素 检验[_First...
c++ 基数排序算法_基数排序算法– C / C ++实现的基础
从零开始的教程世界
07-14 1656
c++ 基数排序算法Radix Sort Algorithm is a unique sorting algorithm that works on the basic principle of numbers being an ensemble of digits. Radix Sort works only on integer values since integers have only ...
C++ is_sorted()排序函数用法详解(深入了解,一文学会)
断点
08-01 4457
find_end() 函数定义在<algorithm>头文件中，常用于在序列 A 中查找序列 B 最后一次出现的位置。例如，有如下 2 个序列： 序列 A：1,2,3,4,5,1,2,3,4,5 序列 B：1,2,3 通过观察不难发现，序列 B 在序列 A 中出现了 2 次，而借助 find_end() 函数，可以轻松的得到序列 A 中最后一个（也就是第 2 个） {1,2,3}。 ......
std::ranges::sort is_sorted is_sorted_until stable_sort partial_sort stable_partition
最新发布
janeqi1987的专栏
02-17 967
std::ranges::sort std::ranges::is_sorted std::ranges::is_sorted_until std::ranges::stable_sort std::ranges::partial_sort std::ranges::stable_partition
C++ is_sorted()函数
ZauberC的博客
02-24 1229
此函数专门用于判断某个序列是否为有序序列。 和之前学习的其它排序函数（比如 sorted() 函数）一样，is_sorted() 函数本质上就是一个函数模板，定义在头文件中。因为，在使用该函数之前，程序中必须先引入此头文件。 is_sorted() 函数有 2 种语法格式，分别是： //判断 [first, last) 区域内的数据是否符合 std::less<T> 排序规则，即是否为升序序列 bool is_sorted (ForwardIterator first, ForwardItera
C++标准模板（STL）（std::fill）
qq_40788199的博客
10-26 1174
1) 赋值给定的 value 给 [first, last) 中的元素。 2) 同 (1) ，但按照 policy 执行。此重载仅若 std::is_execution_policy_v 为 true 才参与重载决议。
详细解说 STL 排序(Sort)
热门推荐
斑竹的程序设计专栏
12-03 3万+
详细解说 STL 排序(Sort) 0 前言: STL，为什么你必须掌握 1 STL提供的Sort 算法 1.1 所有sort算法介绍 1.2 sort 中的比较函数 1.3 sort 的稳定性 1.4 全排序 1.5 局部排序 1.6 nth_element 指定元素排序 1.7 partition 和stable_partition 2 Sort 和容器 3 选择合适的排序函数 4 小结 5
C++ STL算法is_sorted/is_sorted_until（34）
苦逼的程序猿
01-11 448
、is_sorted 函数原型 //判断 [first, last) 区域内的数据是否符合 std::less<T> 排序规则，即是否升序序列 template<class _FwdIt> _NODISCARD inline bool is_sorted(_FwdIt _First, _FwdIt _Last) //判断 [first, last) 区域内的数据是否符合 _Pred 排序规则 template<class _FwdIt, class _Pr>..
15种常见的 C/C++ 排序算法及完整代码，建议收藏！
分享价值，持续输出高质量内容！
12-29 849
本文详阐述了常见的排序算法，分别是：外排序（分段法）、外排序（递归法）、链表排序（选择排序）、链表排序（插入排序）、拓扑结构排序(有向图，无向图)、计数二叉树排序、二叉树排序、桶排序、希尔排序、冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、计数排序、基数排序等排序算法以及完整的实现代码。它首先从未排序序列中找到最小（或最大）的元素，放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小元素，依次类推，直到所有元素均排序完毕。计数排序的时间复杂度为O(n + k)，其中k是输入数据的范围。
C++11新特性应用--介绍几个新增的便利算法(用于排序的几个算法)
一蓑烟雨任平生 也无风雨也无晴
01-20 2171
继续C++11在头文件algorithm中增加的算法。至少我觉得，在stl的算法中，用到最多的就是sort了，我们不去探索sort的源码，就是介绍C++11新增的几个关于排序的函数。对于一个序列，我们怎么知道他是不是有序的呢？这就用到了：is_sorted 原型：template <class ForwardIterator> ForwardIterator is_sorted_until (
boost的函数:is_sorted、is_sorted_until、is_increasing(decreasing)、is_strictly_increasing(decreasing)
不知方向的行走
03-09 786
is_sorted、is_sorted_until、is_increasing(decreasing)、is_strictly_increasing(decreasing)
C++STL算法 is_sorted_until
qq_25047389的博客
09-24 131
寻找连续的两个学生，后一个人的分数比前一个人高，且两个人的分数都小于60分 #include<iostream> #include<cstdlib> #include<algorithm> #include<vector> #include<string> #include<functional> enum GRADE_INDEX { GRADE_0, GRADE_1, GRADE_2, GRADE_3 }; const s
C++ sort()和is_sorted()的升序降序和自定义排序
Yuhan的博客
09-02 3659
我们分别给数组和向量两个名称： int a[]={1,2,3,4,5}; vector<int> v; sort() 头文件：#include<algorithm>; 作用：将数组或向量进行排序； 默认排序方式：升序； 使用格式(数组和vector)： sort(a,a+5); sort(v.begin(),v.end());//默认升序 sort(a,a+5,gr...
c++ 多个字符串排序_Python小白干货宝典：sorted（）函数：列表元素排序
weixin_29117669的博客
01-25 470
定义：sorted() 函数对所有可迭代的对象进行排序操作。内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。语法：sorted 语法：sorted(iterable, cmp=None, key=None, reverse=False)返回值：返回重新排序的列表。参数说明：iterable -- 可迭代对象。cmp -- 比较的函数，这个具有两个参数，参数的...
is_sorted() 函数---一个判断数组和容器是否有序的函数
辉小歌的博客
04-12 2557
需要的头文件： #include<algorithm> 需要的其他东西: using namespace std; 作用： 检查数组或者容器是否被排序好。 默认检查方式： 升序。 特殊要求： 需要C++11的特性。 返回值： true或false。 例子: 转载自: https://blog.youkuaiyun.com/qq_45228537/article/details/100210480 ...
STL is_sorted排序算法
JIWilliams
12-10 1013
排序是要耗费时间的，尤其是在有大量元素时。测试元素段是否已经排好序可以避免不必要的排序操作。如果两个迭代器参数所指定范围内的元素是升序排列的，函数模板 is_sorted() 就会返回 true。 为了能够顺序处理元素，迭代器至少需要是正向迭代器。提醒一下，正向迭代器支持前缀和后缀形式的自增运算。下面是一个使用 is_sorted() 的示例： std::vector&lt;int&gt; ...
泛型算法：查找初始最长有序子序列算法is_sorted_until()
友善啊，朋友的博客
01-17 172
#define debug qDebug()<< int main(int argc, char *argv[]) { QList<int> list = {8, 9, 10, 1, 2, 3, 4, 5, 6}; auto result = std::is_sorted_until(list.begin(), list.end()); debug *result; } 从开头开始查找最长的有序子序列。返回该子序列的end迭代器。 ...
Boost算法库——C++11算法（is_sorted）
一世豁然的专栏
11-06 1748
头文件包含确定序列是否有序的函数。 一、is_sorted 函数is_sorted（sequence）决定一个序列是否按照某种标准完全排序。 如果没有指定比较谓词，则使用std :: less_equal（即，测试是查看序列是否不减少） namespace boost { namespace algorithm { template bool is_sorted (
排序算法总结（C++）
yxx21的博客
04-02 162
排序算法1冒泡排序2 选择排序3 插入排序总结下二分查找 1冒泡排序 改进1 添加sorted 表示是否已经排序 void bubbleSort(vector<int>& array) { int n = array.size() ; for (int i = 0; i < n - 1;i++){ int sorted = true; for (int j = 0; j < n - i - 1;j++){ if
c++十种排序算法的时间复杂度
01-23
### C++ 中十种常见排序算法的时间复杂度 #### 1. 冒泡排序 (Bubble Sort) 冒泡排序是一种简单的排序算法，通过重复遍历要排序的列表，依次比较相邻元素并交换顺序不对的元素。该过程会持续进行直到没有需要交换的元素为止。 - **时间复杂度**: 平均和最坏情况下均为 O(n²)[^3] ```cpp void bubbleSort(int arr[], int n) { for (int i = 0; i < n - 1; ++i) for (int j = 0; j < n - i - 1; ++j) if (arr[j] > arr[j + 1]) std::swap(arr[j], arr[j + 1]); } ``` #### 2. 选择排序 (Selection Sort) 选择排序的工作原理是从未排序部分找到最小(大)元素放到已排序序列的末尾。 - **时间复杂度**: 同样为 O(n²)，无论是在最佳还是最差情况下的性能都较差[^4] ```cpp void selectionSort(int arr[], int n) { for (int i = 0; i < n - 1; ++i) { int minIndex = i; for (int j = i + 1; j < n; ++j) if (arr[j] < arr[minIndex]) minIndex = j; std::swap(arr[i], arr[minIndex]); } } ``` #### 3. 插入排序 (Insertion Sort) 插入排序构建有序数组的一个项接一个项的方式工作，在每一步中将下一个待处理的数据放入已经排好序的部分之中。 - **时间复杂度**: 最佳情况下可以达到 O(n)，但在平均和最糟糕的情况下仍需 O(n²) ```cpp void insertionSort(int arr[], int n) { for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; --j; } arr[j + 1] = key; } } ``` #### 4. 归并排序 (Merge Sort) 归并排序采用分治法策略来解决问题，它不断地把当前数据集分成两半直至不能再分割下去，之后再逐步合并这些子集合形成最终的结果。 - **时间复杂度**: 总体上保持在 O(n log n)，即使对于最不利的情况也是如此[^2] ```cpp void merge(int arr[], int l, int m, int r); void mergeSort(int arr[], int l, int r); // Helper function to perform merging of two halves. void merge(int arr[], int l, int m, int r) { /* ... */ } // Recursive call that divides the array into subarrays and merges them back together. void mergeSort(int arr[], int l, int r) { if (l < r) { int m = l + (r - l) / 2; mergeSort(arr, l, m); mergeSort(arr, m + 1, r); merge(arr, l, m, r); } } ``` #### 5. 快速排序 (Quick Sort) 快速排序也是一种基于分而治之原则的方法，但是它的效率通常高于其他同类方法，因为它能够在大多数实际应用场合下提供接近线性的运行速度。 - **时间复杂度**: 虽然理论上可能退化到 O(n²)，但实际上往往能维持在 O(n log n) 的水平，并且具有较低常数因子 ```cpp int partition(int arr[], int low, int high); void quickSort(int arr[], int low, int high); // Function to find the partition position. int partition(int arr[], int low, int high) { /* ... */ } // Main recursive sorting routine using Lomuto or Hoare's scheme. void quickSort(int arr[], int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); // Before pi quickSort(arr, pi + 1, high); // After pi } } ``` #### 6. 堆排序 (Heap Sort) 堆排序利用了最大/最小堆这一特殊形式的完全二叉树结构来进行高效地排列操作。 - **时间复杂度**: 类似于归并与快排，整体表现稳定在 O(n log n) 左右 ```cpp void heapify(int arr[], int N, int i); void buildMaxHeap(int arr[], int N); void heapSort(int arr[], int N); // To maintain max-heap property after removing root node. void heapify(int arr[], int N, int i) { /* ... */ } // Convert input data structure from unordered list/array form into a valid binary heap representation. void buildMaxHeap(int arr[], int N) { /* ... */ } // Actual implementation which sorts elements by repeatedly extracting maximum value out of remaining unsorted portion until all items are processed. void heapSort(int arr[], int N) { buildMaxHeap(arr, N); for (int i = N - 1; i > 0; --i) { std::swap(arr[0], arr[i]); // Move current largest element at end. heapify(arr, i, 0); // Rebuild reduced size heap excluding last item now placed correctly within sorted section. } } ``` #### 7. 计数排序 (Counting Sort) 计数排序适用于范围有限的小整数值输入场景，能够在线性时间内完成任务而不依赖任何额外的空间开销之外的因素影响。 - **时间复杂度**: 可以做到 O(k+n)，其中 k 表示值域宽度，n 是待排序对象数量[^1] ```cpp void countingSort(int arr[], int n, int range) { int output[n]; // Output array will be stored here temporarily during processing phase. int count[range + 1] = {0}; // Auxiliary storage used internally as frequency counter table indexed according keyspace boundaries. // Store counts of each unique integer found inside source collection. for (int i = 0; i < n; ++i) ++count[arr[i]]; // Transform cumulative frequencies so they represent starting indices instead when writing final result back over original dataset later on. for (int i = 1; i <= range; ++i) count[i] += count[i - 1]; // Build resulting ordered sequence based upon transformed index mappings derived previously above step. for (int i = n - 1; i >= 0; --i) { output[count[arr[i]] - 1] = arr[i]; --count[arr[i]]; } // Copy contents of temporary buffer holding newly arranged values back onto caller provided memory location pointed towards initially passed argument 'arr'. for (int i = 0; i < n; ++i) arr[i] = output[i]; } ``` #### 8. 桶排序 (Bucket Sort) 桶排序先按照一定规则分配给不同的“桶”，然后再分别对各个独立分区内的成员实施更精细级别的分类整理作业流程。 - **时间复杂度**: 如果各区间内分布均匀的话则可近似认为是 O(n+k)，反之可能会恶化至 O(n²) ```cpp void bucketSort(float arr[], int n) { vector<float> b[n]; // Distribute individual entries across multiple containers proportionally relative their magnitude compared against overall span covered entire set being operated upon presently. for (int i = 0; i < n; ++i) b[int(n * arr[i])].push_back(arr[i]); // Apply secondary ordering mechanism recursively down through nested levels till reaching leaf nodes containing singletons only then stop further subdivision attempts altogether eventually producing fully organized outcome once completed successfully throughout whole hierarchy tree traversal path taken sequentially one level deep per iteration cycle pass performed iteratively. for (int i = 0; i < n; ++i) sort(b[i].begin(), b[i].end()); // Concatenate results obtained earlier stages forming complete answer ready presentation purposes finally. int index = 0; for (int i = 0; i < n; ++i) for (size_t j = 0; j < b[i].size(); ++j) arr[index++] = b[i][j]; } ``` #### 9. 基数排序 (Radix Sort) 基数排序针对多关键字记录类型设计的一种非比较型整数排序方案，主要特点是按位逐轮次扫描处理每一位上的数字大小关系从而间接实现了全局层面的整体升序降序调整效果。 - **时间复杂度**: 对于固定长度编码表示方式而言基本恒定等于 O(d*(n+b))，这里 d 意味着最高有效位所在
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人才程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值