Sophie

Sophie

distrib > Mageia > 7 > armv7hl > media > core-updates > by-pkgid > bfb47da7e0322bcb0e23e4b1838d9db9 > files > 1315

libstdc++-docs-8.4.0-1.mga7.noarch.rpm

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<meta name="generator" content="Doxygen 1.8.15"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>libstdc++: Sorting</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="navtree.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="resize.js"></script>
<script type="text/javascript" src="navtreedata.js"></script>
<script type="text/javascript" src="navtree.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
  $(document).ready(initResizable);
/* @license-end */</script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr style="height: 56px;">
  <td id="projectalign" style="padding-left: 0.5em;">
   <div id="projectname">libstdc++
   </div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.8.15 -->
</div><!-- top -->
<div id="side-nav" class="ui-resizable side-nav-resizable">
  <div id="nav-tree">
    <div id="nav-tree-contents">
      <div id="nav-sync" class="sync"></div>
    </div>
  </div>
  <div id="splitbar" style="-moz-user-select:none;" 
       class="ui-resizable-handle">
  </div>
</div>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
$(document).ready(function(){initNavTree('a01485.html','');});
/* @license-end */
</script>
<div id="doc-content">
<div class="header">
  <div class="summary">
<a href="#groups">Modules</a> &#124;
<a href="#func-members">Functions</a>  </div>
  <div class="headertitle">
<div class="title">Sorting<div class="ingroups"><a class="el" href="a01482.html">Algorithms</a></div></div>  </div>
</div><!--header-->
<div class="contents">
<div class="dynheader">
Collaboration diagram for Sorting:</div>
<div class="dyncontent">
<center><table><tr><td><div class="center"><iframe scrolling="no" frameborder="0" src="a01485.svg" width="347" height="131"><p><b>This browser is not able to show SVG: try Firefox, Chrome, Safari, or Opera instead.</b></p></iframe>
</div>
</td></tr></table></center>
</div>
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="groups"></a>
Modules</h2></td></tr>
<tr class="memitem:a01487"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="a01487.html">Binary Search</a></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a01506"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="a01506.html">Heap</a></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a01486"><td class="memItemLeft" align="right" valign="top">&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="a01486.html">Set Operation</a></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
Functions</h2></td></tr>
<tr class="memitem:ga5e5479e1ac5e92b0c1f77bcf762d07e9"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator &gt; </td></tr>
<tr class="memitem:ga5e5479e1ac5e92b0c1f77bcf762d07e9"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga5e5479e1ac5e92b0c1f77bcf762d07e9">std::inplace_merge</a> (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)</td></tr>
<tr class="separator:ga5e5479e1ac5e92b0c1f77bcf762d07e9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gaf6a8379ab8a648fd05d52ed0632081fa"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gaf6a8379ab8a648fd05d52ed0632081fa"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gaf6a8379ab8a648fd05d52ed0632081fa">std::inplace_merge</a> (_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gaf6a8379ab8a648fd05d52ed0632081fa"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga3a5337f3b4d2394123033a6c6279abbb"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator &gt; </td></tr>
<tr class="memitem:ga3a5337f3b4d2394123033a6c6279abbb"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga3a5337f3b4d2394123033a6c6279abbb">std::is_sorted</a> (_ForwardIterator __first, _ForwardIterator __last)</td></tr>
<tr class="separator:ga3a5337f3b4d2394123033a6c6279abbb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gaba6fffa1d87bd34155dcd980bbe02a53"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gaba6fffa1d87bd34155dcd980bbe02a53"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gaba6fffa1d87bd34155dcd980bbe02a53">std::is_sorted</a> (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gaba6fffa1d87bd34155dcd980bbe02a53"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga76cfb20887dfce8ce554053b6b6935c9"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator &gt; </td></tr>
<tr class="memitem:ga76cfb20887dfce8ce554053b6b6935c9"><td class="memTemplItemLeft" align="right" valign="top">_ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga76cfb20887dfce8ce554053b6b6935c9">std::is_sorted_until</a> (_ForwardIterator __first, _ForwardIterator __last)</td></tr>
<tr class="separator:ga76cfb20887dfce8ce554053b6b6935c9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga07069e2148fa7ce5fc6df47a43fd8240"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga07069e2148fa7ce5fc6df47a43fd8240"><td class="memTemplItemLeft" align="right" valign="top">_ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga07069e2148fa7ce5fc6df47a43fd8240">std::is_sorted_until</a> (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga07069e2148fa7ce5fc6df47a43fd8240"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga869d1fd6bb4929ef491edbfdbcc9f7b9"><td class="memTemplParams" colspan="2">template&lt;typename _II1 , typename _II2 &gt; </td></tr>
<tr class="memitem:ga869d1fd6bb4929ef491edbfdbcc9f7b9"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga869d1fd6bb4929ef491edbfdbcc9f7b9">std::lexicographical_compare</a> (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)</td></tr>
<tr class="separator:ga869d1fd6bb4929ef491edbfdbcc9f7b9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gae179ce2d015dc0908973644687dce4c6"><td class="memTemplParams" colspan="2">template&lt;typename _II1 , typename _II2 , typename _Compare &gt; </td></tr>
<tr class="memitem:gae179ce2d015dc0908973644687dce4c6"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gae179ce2d015dc0908973644687dce4c6">std::lexicographical_compare</a> (_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp)</td></tr>
<tr class="separator:gae179ce2d015dc0908973644687dce4c6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga84d30d8c4b3f2cbe8ec2055c34a578da"><td class="memTemplParams" colspan="2">template&lt;typename _Tp &gt; </td></tr>
<tr class="memitem:ga84d30d8c4b3f2cbe8ec2055c34a578da"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR const _Tp &amp;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga84d30d8c4b3f2cbe8ec2055c34a578da">std::max</a> (const _Tp &amp;__a, const _Tp &amp;__b)</td></tr>
<tr class="separator:ga84d30d8c4b3f2cbe8ec2055c34a578da"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga2a22232a7bcd3b1f87a45a5fb01ac9c3"><td class="memTemplParams" colspan="2">template&lt;typename _Tp , typename _Compare &gt; </td></tr>
<tr class="memitem:ga2a22232a7bcd3b1f87a45a5fb01ac9c3"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR const _Tp &amp;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga2a22232a7bcd3b1f87a45a5fb01ac9c3">std::max</a> (const _Tp &amp;__a, const _Tp &amp;__b, _Compare __comp)</td></tr>
<tr class="separator:ga2a22232a7bcd3b1f87a45a5fb01ac9c3"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga6c310c6d1db64624d3097dd06838ef9b"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator &gt; </td></tr>
<tr class="memitem:ga6c310c6d1db64624d3097dd06838ef9b"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR _ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga6c310c6d1db64624d3097dd06838ef9b">std::max_element</a> (_ForwardIterator __first, _ForwardIterator __last)</td></tr>
<tr class="separator:ga6c310c6d1db64624d3097dd06838ef9b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gab0bc7a1a77eead2e4af61c6506230104"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gab0bc7a1a77eead2e4af61c6506230104"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR _ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gab0bc7a1a77eead2e4af61c6506230104">std::max_element</a> (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gab0bc7a1a77eead2e4af61c6506230104"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gabb18bc670a27e539246a2eb154f60351"><td class="memTemplParams" colspan="2">template&lt;typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator &gt; </td></tr>
<tr class="memitem:gabb18bc670a27e539246a2eb154f60351"><td class="memTemplItemLeft" align="right" valign="top">_OutputIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gabb18bc670a27e539246a2eb154f60351">std::merge</a> (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)</td></tr>
<tr class="separator:gabb18bc670a27e539246a2eb154f60351"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga7f7771648d074e296d019153633efa8d"><td class="memTemplParams" colspan="2">template&lt;typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga7f7771648d074e296d019153633efa8d"><td class="memTemplItemLeft" align="right" valign="top">_OutputIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga7f7771648d074e296d019153633efa8d">std::merge</a> (_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)</td></tr>
<tr class="separator:ga7f7771648d074e296d019153633efa8d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gad48656de2f272a953455e1fff2532125"><td class="memTemplParams" colspan="2">template&lt;typename _Tp &gt; </td></tr>
<tr class="memitem:gad48656de2f272a953455e1fff2532125"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR const _Tp &amp;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gad48656de2f272a953455e1fff2532125">std::min</a> (const _Tp &amp;__a, const _Tp &amp;__b)</td></tr>
<tr class="separator:gad48656de2f272a953455e1fff2532125"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga6499dc0f7db12560643a3b79db5357f6"><td class="memTemplParams" colspan="2">template&lt;typename _Tp , typename _Compare &gt; </td></tr>
<tr class="memitem:ga6499dc0f7db12560643a3b79db5357f6"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR const _Tp &amp;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga6499dc0f7db12560643a3b79db5357f6">std::min</a> (const _Tp &amp;__a, const _Tp &amp;__b, _Compare __comp)</td></tr>
<tr class="separator:ga6499dc0f7db12560643a3b79db5357f6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga1de5df2bd9b3d6e5716e82c95ae6df2a"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator &gt; </td></tr>
<tr class="memitem:ga1de5df2bd9b3d6e5716e82c95ae6df2a"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR _ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga1de5df2bd9b3d6e5716e82c95ae6df2a">std::min_element</a> (_ForwardIterator __first, _ForwardIterator __last)</td></tr>
<tr class="separator:ga1de5df2bd9b3d6e5716e82c95ae6df2a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gaef494344047573854d8e2d34070fd2b4"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gaef494344047573854d8e2d34070fd2b4"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR _ForwardIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gaef494344047573854d8e2d34070fd2b4">std::min_element</a> (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gaef494344047573854d8e2d34070fd2b4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga67c7bf4c4b3c5cbf251a3812e06e0308"><td class="memTemplParams" colspan="2">template&lt;typename _Tp &gt; </td></tr>
<tr class="memitem:ga67c7bf4c4b3c5cbf251a3812e06e0308"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; const _Tp &amp;, const _Tp &amp; &gt;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga67c7bf4c4b3c5cbf251a3812e06e0308">std::minmax</a> (const _Tp &amp;__a, const _Tp &amp;__b)</td></tr>
<tr class="separator:ga67c7bf4c4b3c5cbf251a3812e06e0308"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga74c98df71fd53702699434040aacb249"><td class="memTemplParams" colspan="2">template&lt;typename _Tp , typename _Compare &gt; </td></tr>
<tr class="memitem:ga74c98df71fd53702699434040aacb249"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; const _Tp &amp;, const _Tp &amp; &gt;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga74c98df71fd53702699434040aacb249">std::minmax</a> (const _Tp &amp;__a, const _Tp &amp;__b, _Compare __comp)</td></tr>
<tr class="separator:ga74c98df71fd53702699434040aacb249"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gabaec6cf28af83896d2253693d08d4cfe"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator &gt; </td></tr>
<tr class="memitem:gabaec6cf28af83896d2253693d08d4cfe"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; _ForwardIterator, _ForwardIterator &gt;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gabaec6cf28af83896d2253693d08d4cfe">std::minmax_element</a> (_ForwardIterator __first, _ForwardIterator __last)</td></tr>
<tr class="separator:gabaec6cf28af83896d2253693d08d4cfe"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gaa8e6bf20463e0f605a548e7d7efb099d"><td class="memTemplParams" colspan="2">template&lt;typename _ForwardIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gaa8e6bf20463e0f605a548e7d7efb099d"><td class="memTemplItemLeft" align="right" valign="top">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; _ForwardIterator, _ForwardIterator &gt;&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gaa8e6bf20463e0f605a548e7d7efb099d">std::minmax_element</a> (_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gaa8e6bf20463e0f605a548e7d7efb099d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga0a84cc794bbfca40a0664edaedd05c34"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator &gt; </td></tr>
<tr class="memitem:ga0a84cc794bbfca40a0664edaedd05c34"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga0a84cc794bbfca40a0664edaedd05c34">std::next_permutation</a> (_BidirectionalIterator __first, _BidirectionalIterator __last)</td></tr>
<tr class="separator:ga0a84cc794bbfca40a0664edaedd05c34"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga84b626c10da677e22bdbbb058cc8e7da"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga84b626c10da677e22bdbbb058cc8e7da"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga84b626c10da677e22bdbbb058cc8e7da">std::next_permutation</a> (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga84b626c10da677e22bdbbb058cc8e7da"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga3a4f2ca9c1c627576aeeaa99181c8c63"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator &gt; </td></tr>
<tr class="memitem:ga3a4f2ca9c1c627576aeeaa99181c8c63"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga3a4f2ca9c1c627576aeeaa99181c8c63">std::nth_element</a> (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)</td></tr>
<tr class="separator:ga3a4f2ca9c1c627576aeeaa99181c8c63"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga6d43f0d62204409f18762c8e1bf1867b"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga6d43f0d62204409f18762c8e1bf1867b"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga6d43f0d62204409f18762c8e1bf1867b">std::nth_element</a> (_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga6d43f0d62204409f18762c8e1bf1867b"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga91f25d546637f075de3958a25928b687"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator &gt; </td></tr>
<tr class="memitem:ga91f25d546637f075de3958a25928b687"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga91f25d546637f075de3958a25928b687">std::partial_sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)</td></tr>
<tr class="separator:ga91f25d546637f075de3958a25928b687"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga6401ff7e25d2ef7a6119d894cb40eec0"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga6401ff7e25d2ef7a6119d894cb40eec0"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga6401ff7e25d2ef7a6119d894cb40eec0">std::partial_sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga6401ff7e25d2ef7a6119d894cb40eec0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga7b262260421978833cc1b1c6b3969bb4"><td class="memTemplParams" colspan="2">template&lt;typename _InputIterator , typename _RandomAccessIterator &gt; </td></tr>
<tr class="memitem:ga7b262260421978833cc1b1c6b3969bb4"><td class="memTemplItemLeft" align="right" valign="top">_RandomAccessIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga7b262260421978833cc1b1c6b3969bb4">std::partial_sort_copy</a> (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)</td></tr>
<tr class="separator:ga7b262260421978833cc1b1c6b3969bb4"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gaf53e3f9d5e3c9cd4d36a0801d411e324"><td class="memTemplParams" colspan="2">template&lt;typename _InputIterator , typename _RandomAccessIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gaf53e3f9d5e3c9cd4d36a0801d411e324"><td class="memTemplItemLeft" align="right" valign="top">_RandomAccessIterator&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gaf53e3f9d5e3c9cd4d36a0801d411e324">std::partial_sort_copy</a> (_InputIterator __first, _InputIterator __last, _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)</td></tr>
<tr class="separator:gaf53e3f9d5e3c9cd4d36a0801d411e324"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga0b0e35a43f5f87ea1c66363be3a34619"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator &gt; </td></tr>
<tr class="memitem:ga0b0e35a43f5f87ea1c66363be3a34619"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga0b0e35a43f5f87ea1c66363be3a34619">std::prev_permutation</a> (_BidirectionalIterator __first, _BidirectionalIterator __last)</td></tr>
<tr class="separator:ga0b0e35a43f5f87ea1c66363be3a34619"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga44e9b1d39001f68fa9fcb408b25a77f0"><td class="memTemplParams" colspan="2">template&lt;typename _BidirectionalIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga44e9b1d39001f68fa9fcb408b25a77f0"><td class="memTemplItemLeft" align="right" valign="top">bool&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga44e9b1d39001f68fa9fcb408b25a77f0">std::prev_permutation</a> (_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga44e9b1d39001f68fa9fcb408b25a77f0"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga4ea03048647c50ea7cbdd5da30e82755"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator &gt; </td></tr>
<tr class="memitem:ga4ea03048647c50ea7cbdd5da30e82755"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga4ea03048647c50ea7cbdd5da30e82755">std::sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __last)</td></tr>
<tr class="separator:ga4ea03048647c50ea7cbdd5da30e82755"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:gae3c0067ae83db1824367ded659a960b2"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:gae3c0067ae83db1824367ded659a960b2"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#gae3c0067ae83db1824367ded659a960b2">std::sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)</td></tr>
<tr class="separator:gae3c0067ae83db1824367ded659a960b2"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga7d8bb8e52b7b0e80301dcbec17225b4a"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator &gt; </td></tr>
<tr class="memitem:ga7d8bb8e52b7b0e80301dcbec17225b4a"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga7d8bb8e52b7b0e80301dcbec17225b4a">std::stable_sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __last)</td></tr>
<tr class="separator:ga7d8bb8e52b7b0e80301dcbec17225b4a"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ga3a3ce3aa8ac2297f8290939a7988596d"><td class="memTemplParams" colspan="2">template&lt;typename _RandomAccessIterator , typename _Compare &gt; </td></tr>
<tr class="memitem:ga3a3ce3aa8ac2297f8290939a7988596d"><td class="memTemplItemLeft" align="right" valign="top">void&#160;</td><td class="memTemplItemRight" valign="bottom"><a class="el" href="a01485.html#ga3a3ce3aa8ac2297f8290939a7988596d">std::stable_sort</a> (_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)</td></tr>
<tr class="separator:ga3a3ce3aa8ac2297f8290939a7988596d"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
<h2 class="groupheader">Function Documentation</h2>
<a id="ga5e5479e1ac5e92b0c1f77bcf762d07e9"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga5e5479e1ac5e92b0c1f77bcf762d07e9">&#9670;&nbsp;</a></span>inplace_merge() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::inplace_merge </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__middle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Merges two sorted ranges in place. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__middle</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Merges two sorted and consecutive ranges, [__first,__middle) and [__middle,__last), and puts the result in [__first,__last). The output will be sorted. The sort is <em>stable</em>, that is, for equivalent elements in the two ranges, elements from the first range will always come before elements from the second.</p>
<p>If enough additional memory is available, this takes (__last-__first)-1 comparisons. Otherwise an NlogN algorithm is used, where N is distance(__first,__last). </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l02574">2574</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gaf6a8379ab8a648fd05d52ed0632081fa"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gaf6a8379ab8a648fd05d52ed0632081fa">&#9670;&nbsp;</a></span>inplace_merge() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::inplace_merge </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__middle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Merges two sorted ranges in place. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__middle</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A functor to use for comparisons. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Merges two sorted and consecutive ranges, [__first,__middle) and [middle,last), and puts the result in [__first,__last). The output will be sorted. The sort is <em>stable</em>, that is, for equivalent elements in the two ranges, elements from the first range will always come before elements from the second.</p>
<p>If enough additional memory is available, this takes (__last-__first)-1 comparisons. Otherwise an NlogN algorithm is used, where N is distance(__first,__last).</p>
<p>The comparison function should have the same effects on ordering as the function used for the initial sort. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l02615">2615</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga3a5337f3b4d2394123033a6c6279abbb"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga3a5337f3b4d2394123033a6c6279abbb">&#9670;&nbsp;</a></span>is_sorted() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::is_sorted </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines whether the elements of a sequence are sorted. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>True if the elements are sorted, false otherwise. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03209">3209</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

<p class="reference">References <a class="el" href="a00527_source.html#l03276">std::is_sorted_until()</a>.</p>

</div>
</div>
<a id="gaba6fffa1d87bd34155dcd980bbe02a53"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gaba6fffa1d87bd34155dcd980bbe02a53">&#9670;&nbsp;</a></span>is_sorted() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::is_sorted </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines whether the elements of a sequence are sorted according to a comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>True if the elements are sorted, false otherwise. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03223">3223</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

<p class="reference">References <a class="el" href="a00527_source.html#l03276">std::is_sorted_until()</a>.</p>

</div>
</div>
<a id="ga76cfb20887dfce8ce554053b6b6935c9"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga76cfb20887dfce8ce554053b6b6935c9">&#9670;&nbsp;</a></span>is_sorted_until() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_ForwardIterator std::is_sorted_until </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines the end of a sorted sequence. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the last iterator i in [__first, __last) for which the range [__first, i) is sorted. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03252">3252</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga07069e2148fa7ce5fc6df47a43fd8240"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga07069e2148fa7ce5fc6df47a43fd8240">&#9670;&nbsp;</a></span>is_sorted_until() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_ForwardIterator std::is_sorted_until </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines the end of a sorted sequence using comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the last iterator i in [__first, __last) for which the range [__first, i) is sorted. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03276">3276</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

<p class="reference">Referenced by <a class="el" href="a00527_source.html#l03209">std::is_sorted()</a>.</p>

</div>
</div>
<a id="ga869d1fd6bb4929ef491edbfdbcc9f7b9"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga869d1fd6bb4929ef491edbfdbcc9f7b9">&#9670;&nbsp;</a></span>lexicographical_compare() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _II1 , typename _II2 &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::lexicographical_compare </td>
          <td>(</td>
          <td class="paramtype">_II1&#160;</td>
          <td class="paramname"><em>__first1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II1&#160;</td>
          <td class="paramname"><em>__last1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II2&#160;</td>
          <td class="paramname"><em>__first2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II2&#160;</td>
          <td class="paramname"><em>__last2</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Performs <b>dictionary</b> comparison on ranges. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first1</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__last1</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__first2</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__last2</td><td>An input iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A boolean true or false.</dd></dl>
<p><em>Returns true if the sequence of elements defined by the range [first1,last1) is lexicographically less than the sequence of elements defined by the range [first2,last2). Returns false otherwise.</em> (Quoted from [25.3.8]/1.) If the iterators are all character pointers, then this is an inline call to <code>memcmp</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l01221">1221</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

</div>
</div>
<a id="gae179ce2d015dc0908973644687dce4c6"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gae179ce2d015dc0908973644687dce4c6">&#9670;&nbsp;</a></span>lexicographical_compare() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _II1 , typename _II2 , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::lexicographical_compare </td>
          <td>(</td>
          <td class="paramtype">_II1&#160;</td>
          <td class="paramname"><em>__first1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II1&#160;</td>
          <td class="paramname"><em>__last1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II2&#160;</td>
          <td class="paramname"><em>__first2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_II2&#160;</td>
          <td class="paramname"><em>__last2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Performs <b>dictionary</b> comparison on ranges. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first1</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__last1</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__first2</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__last2</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A <a class="el" href="a01501.html">comparison functor</a>. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A boolean true or false.</dd></dl>
<p>The same as the four-parameter <code>lexicographical_compare</code>, but uses the comp parameter instead of <code>&lt;</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l01257">1257</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

<p class="reference">Referenced by <a class="el" href="a00335_source.html#l01432">std::operator&lt;()</a>.</p>

</div>
</div>
<a id="ga84d30d8c4b3f2cbe8ec2055c34a578da"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga84d30d8c4b3f2cbe8ec2055c34a578da">&#9670;&nbsp;</a></span>max() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR const _Tp &amp; std::max </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>This does what you think it does. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The greater of the parameters.</dd></dl>
<p>This is the simple classic generic implementation. It will work on temporary expressions, since they are only evaluated once, unlike a preprocessor macro. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l00219">219</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

<p class="reference">Referenced by <a class="el" href="a00941_source.html#l00332">__gnu_parallel::__parallel_nth_element()</a>, <a class="el" href="a00539_source.html#l00683">std::deque&lt; _StateSeqT &gt;::_M_initialize_map()</a>, <a class="el" href="a00320_source.html#l00919">std::deque&lt; _StateSeqT &gt;::_M_reallocate_map()</a>, <a class="el" href="a00452_source.html#l00958">std::discard_block_engine&lt; _RandomNumberEngine, __p, __r &gt;::max()</a>, <a class="el" href="a00452_source.html#l01397">std::shuffle_order_engine&lt; _RandomNumberEngine, __k &gt;::max()</a>, and <a class="el" href="a00914_source.html#l00388">__gnu_parallel::multiseq_selection()</a>.</p>

</div>
</div>
<a id="ga2a22232a7bcd3b1f87a45a5fb01ac9c3"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga2a22232a7bcd3b1f87a45a5fb01ac9c3">&#9670;&nbsp;</a></span>max() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR const _Tp &amp; std::max </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>This does what you think it does. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__comp</td><td>A <a class="el" href="a01501.html">comparison functor</a>. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The greater of the parameters.</dd></dl>
<p>This will work on temporary expressions, since they are only evaluated once, unlike a preprocessor macro. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l00265">265</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

</div>
</div>
<a id="ga6c310c6d1db64624d3097dd06838ef9b"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga6c310c6d1db64624d3097dd06838ef9b">&#9670;&nbsp;</a></span>max_element() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR _ForwardIterator std::max_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return the maximum element in a range. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Iterator referencing the first instance of the largest value. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05674">5674</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gab0bc7a1a77eead2e4af61c6506230104"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gab0bc7a1a77eead2e4af61c6506230104">&#9670;&nbsp;</a></span>max_element() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR _ForwardIterator std::max_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return the maximum element in a range using comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
    <tr><td class="paramname">__comp</td><td>Comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Iterator referencing the first instance of the largest value according to __comp. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05699">5699</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gabb18bc670a27e539246a2eb154f60351"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gabb18bc670a27e539246a2eb154f60351">&#9670;&nbsp;</a></span>merge() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_OutputIterator std::merge </td>
          <td>(</td>
          <td class="paramtype">_InputIterator1&#160;</td>
          <td class="paramname"><em>__first1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator1&#160;</td>
          <td class="paramname"><em>__last1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator2&#160;</td>
          <td class="paramname"><em>__first2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator2&#160;</td>
          <td class="paramname"><em>__last2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_OutputIterator&#160;</td>
          <td class="paramname"><em>__result</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Merges two sorted ranges. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first1</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__first2</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last1</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last2</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__result</td><td>An iterator pointing to the end of the merged range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the first element <em>not less than</em> <em>val</em>.</dd></dl>
<p>Merges the ranges <code></code>[__first1,__last1) and <code></code>[__first2,__last2) into the sorted range <code></code>[__result, __result + (__last1-__first1) + (__last2-__first2)). Both input ranges must be sorted, and the output range must not overlap with either of the input ranges. The sort is <em>stable</em>, that is, for equivalent elements in the two ranges, elements from the first range will always come before elements from the second. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04916">4916</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga7f7771648d074e296d019153633efa8d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga7f7771648d074e296d019153633efa8d">&#9670;&nbsp;</a></span>merge() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _InputIterator1 , typename _InputIterator2 , typename _OutputIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_OutputIterator std::merge </td>
          <td>(</td>
          <td class="paramtype">_InputIterator1&#160;</td>
          <td class="paramname"><em>__first1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator1&#160;</td>
          <td class="paramname"><em>__last1</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator2&#160;</td>
          <td class="paramname"><em>__first2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator2&#160;</td>
          <td class="paramname"><em>__last2</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_OutputIterator&#160;</td>
          <td class="paramname"><em>__result</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Merges two sorted ranges. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first1</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__first2</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last1</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last2</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__result</td><td>An iterator pointing to the end of the merged range. </td></tr>
    <tr><td class="paramname">__comp</td><td>A functor to use for comparisons. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator pointing to the first element "not less
                than" <em>val</em>.</dd></dl>
<p>Merges the ranges <code></code>[__first1,__last1) and <code></code>[__first2,__last2) into the sorted range <code></code>[__result, __result + (__last1-__first1) + (__last2-__first2)). Both input ranges must be sorted, and the output range must not overlap with either of the input ranges. The sort is <em>stable</em>, that is, for equivalent elements in the two ranges, elements from the first range will always come before elements from the second.</p>
<p>The comparison function should have the same effects on ordering as the function used for the initial sort. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04966">4966</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gad48656de2f272a953455e1fff2532125"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gad48656de2f272a953455e1fff2532125">&#9670;&nbsp;</a></span>min() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR const _Tp &amp; std::min </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>This does what you think it does. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The lesser of the parameters.</dd></dl>
<p>This is the simple classic generic implementation. It will work on temporary expressions, since they are only evaluated once, unlike a preprocessor macro. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l00195">195</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

<p class="reference">Referenced by <a class="el" href="a00953_source.html#l00265">__gnu_parallel::__parallel_random_shuffle_drs()</a>, <a class="el" href="a00947_source.html#l00051">__gnu_parallel::__parallel_sort_qs_divide()</a>, <a class="el" href="a00527_source.html#l05746">std::__sample()</a>, <a class="el" href="a00956_source.html#l00081">__gnu_parallel::__search_template()</a>, <a class="el" href="a00953_source.html#l00410">__gnu_parallel::__sequential_random_shuffle()</a>, <a class="el" href="a01100_source.html#l00460">__gnu_cxx::__versa_string&lt; _CharT, _Traits, _Alloc, _Base &gt;::compare()</a>, <a class="el" href="a00293_source.html#l01385">std::basic_string&lt; char &gt;::compare()</a>, <a class="el" href="a17058_source.html#l03313">std::generate_canonical()</a>, <a class="el" href="a00452_source.html#l00951">std::discard_block_engine&lt; _RandomNumberEngine, __p, __r &gt;::min()</a>, <a class="el" href="a00452_source.html#l01390">std::shuffle_order_engine&lt; _RandomNumberEngine, __k &gt;::min()</a>, <a class="el" href="a00605_source.html#l00046">std::basic_streambuf&lt; _Elem, _Tr &gt;::xsgetn()</a>, and <a class="el" href="a00605_source.html#l00080">std::basic_streambuf&lt; _Elem, _Tr &gt;::xsputn()</a>.</p>

</div>
</div>
<a id="ga6499dc0f7db12560643a3b79db5357f6"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga6499dc0f7db12560643a3b79db5357f6">&#9670;&nbsp;</a></span>min() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR const _Tp &amp; std::min </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>This does what you think it does. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__comp</td><td>A <a class="el" href="a01501.html">comparison functor</a>. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>The lesser of the parameters.</dd></dl>
<p>This will work on temporary expressions, since they are only evaluated once, unlike a preprocessor macro. </p>

<p class="definition">Definition at line <a class="el" href="a00530_source.html#l00243">243</a> of file <a class="el" href="a00530_source.html">stl_algobase.h</a>.</p>

</div>
</div>
<a id="ga1de5df2bd9b3d6e5716e82c95ae6df2a"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga1de5df2bd9b3d6e5716e82c95ae6df2a">&#9670;&nbsp;</a></span>min_element() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR _ForwardIterator std::min_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return the minimum element in a range. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Iterator referencing the first instance of the smallest value. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05610">5610</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gaef494344047573854d8e2d34070fd2b4"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gaef494344047573854d8e2d34070fd2b4">&#9670;&nbsp;</a></span>min_element() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR _ForwardIterator std::min_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return the minimum element in a range using comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
    <tr><td class="paramname">__comp</td><td>Comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Iterator referencing the first instance of the smallest value according to __comp. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05635">5635</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga67c7bf4c4b3c5cbf251a3812e06e0308"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga67c7bf4c4b3c5cbf251a3812e06e0308">&#9670;&nbsp;</a></span>minmax() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; const _Tp &amp;, const _Tp &amp; &gt; std::minmax </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines min and max at once as an ordered pair. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A pair(__b, __a) if __b is smaller than __a, pair(__a, __b) otherwise. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03302">3302</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga74c98df71fd53702699434040aacb249"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga74c98df71fd53702699434040aacb249">&#9670;&nbsp;</a></span>minmax() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _Tp , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt; const _Tp &amp;, const _Tp &amp; &gt; std::minmax </td>
          <td>(</td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__a</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">const _Tp &amp;&#160;</td>
          <td class="paramname"><em>__b</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Determines min and max at once as an ordered pair. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__a</td><td>A thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__b</td><td>Another thing of arbitrary type. </td></tr>
    <tr><td class="paramname">__comp</td><td>A <a class="el" href="a01501.html">comparison functor </a>. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>A pair(__b, __a) if __b is smaller than __a, pair(__a, __b) otherwise. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03323">3323</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gabaec6cf28af83896d2253693d08d4cfe"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gabaec6cf28af83896d2253693d08d4cfe">&#9670;&nbsp;</a></span>minmax_element() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt;_ForwardIterator, _ForwardIterator&gt; std::minmax_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return a pair of iterators pointing to the minimum and maximum elements in a range. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>make_pair(m, M), where m is the first iterator i in [__first, __last) such that no other element in the range is smaller, and where M is the last iterator i in [__first, __last) such that no other element in the range is larger. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03403">3403</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gaa8e6bf20463e0f605a548e7d7efb099d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gaa8e6bf20463e0f605a548e7d7efb099d">&#9670;&nbsp;</a></span>minmax_element() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _ForwardIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_GLIBCXX14_CONSTEXPR <a class="el" href="a07767.html">pair</a>&lt;_ForwardIterator, _ForwardIterator&gt; std::minmax_element </td>
          <td>(</td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_ForwardIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Return a pair of iterators pointing to the minimum and maximum elements in a range. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
    <tr><td class="paramname">__comp</td><td>Comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>make_pair(m, M), where m is the first iterator i in [__first, __last) such that no other element in the range is smaller, and where M is the last iterator i in [__first, __last) such that no other element in the range is larger. </dd></dl>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03431">3431</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga0a84cc794bbfca40a0664edaedd05c34"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga0a84cc794bbfca40a0664edaedd05c34">&#9670;&nbsp;</a></span>next_permutation() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::next_permutation </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Permute range into the next <em>dictionary</em> ordering. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>False if wrapped to first permutation, true otherwise.</dd></dl>
<p>Treats all permutations of the range as a set of <em>dictionary</em> sorted sequences. Permutes the current sequence into the next one of this set. Returns true if there are more sequences to generate. If the sequence is the largest of the set, the smallest is generated and false returned. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l02954">2954</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga84b626c10da677e22bdbbb058cc8e7da"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga84b626c10da677e22bdbbb058cc8e7da">&#9670;&nbsp;</a></span>next_permutation() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::next_permutation </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Permute range into the next <em>dictionary</em> ordering using comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>False if wrapped to first permutation, true otherwise.</dd></dl>
<p>Treats all permutations of the range [__first,__last) as a set of <em>dictionary</em> sorted sequences ordered by <code>__comp</code>. Permutes the current sequence into the next one of this set. Returns true if there are more sequences to generate. If the sequence is the largest of the set, the smallest is generated and false returned. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l02986">2986</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga3a4f2ca9c1c627576aeeaa99181c8c63"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga3a4f2ca9c1c627576aeeaa99181c8c63">&#9670;&nbsp;</a></span>nth_element() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::nth_element </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__nth</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort a sequence just enough to find a particular position. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__nth</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Rearranges the elements in the range <code></code>[__first,__last) so that <code>*__nth</code> is the same element that would have been in that position had the whole sequence been sorted. The elements either side of <code>*__nth</code> are not completely sorted, but for any iterator <em>i</em> in the range <code></code>[__first,__nth) and any iterator <em>j</em> in the range <code></code>[__nth,__last) it holds that *j &lt; *i is false. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04748">4748</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga6d43f0d62204409f18762c8e1bf1867b"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga6d43f0d62204409f18762c8e1bf1867b">&#9670;&nbsp;</a></span>nth_element() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::nth_element </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__nth</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort a sequence just enough to find a particular position using a predicate for comparison. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__nth</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Rearranges the elements in the range <code></code>[__first,__last) so that <code>*__nth</code> is the same element that would have been in that position had the whole sequence been sorted. The elements either side of <code>*__nth</code> are not completely sorted, but for any iterator <em>i</em> in the range <code></code>[__first,__nth) and any iterator <em>j</em> in the range <code></code>[__nth,__last) it holds that <code>__comp(*j,*i)</code> is false. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04787">4787</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga91f25d546637f075de3958a25928b687"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga91f25d546637f075de3958a25928b687">&#9670;&nbsp;</a></span>partial_sort() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::partial_sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__middle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the smallest elements of a sequence. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__middle</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the smallest <code></code>(__middle-__first) elements in the range <code></code>[first,last) and moves them to the range <code></code>[__first,__middle). The order of the remaining elements in the range <code></code>[__middle,__last) is undefined. After the sort if <em>i</em> and <em>j</em> are iterators in the range <code></code>[__first,__middle) such that i precedes j and <em>k</em> is an iterator in the range <code></code>[__middle,__last) then *j&lt;*i and *k&lt;*i are both false. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04674">4674</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga6401ff7e25d2ef7a6119d894cb40eec0"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga6401ff7e25d2ef7a6119d894cb40eec0">&#9670;&nbsp;</a></span>partial_sort() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::partial_sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__middle</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the smallest elements of a sequence using a predicate for comparison. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__middle</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the smallest <code></code>(__middle-__first) elements in the range <code></code>[__first,__last) and moves them to the range <code></code>[__first,__middle). The order of the remaining elements in the range <code></code>[__middle,__last) is undefined. After the sort if <em>i</em> and <em>j</em> are iterators in the range <code></code>[__first,__middle) such that i precedes j and <em>k</em> is an iterator in the range <code></code>[__middle,__last) then <code>*__comp</code>(j,*i) and <code>__comp(*k,*i)</code> are both false. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04712">4712</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga7b262260421978833cc1b1c6b3969bb4"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga7b262260421978833cc1b1c6b3969bb4">&#9670;&nbsp;</a></span>partial_sort_copy() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _InputIterator , typename _RandomAccessIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_RandomAccessIterator std::partial_sort_copy </td>
          <td>(</td>
          <td class="paramtype">_InputIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__result_first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__result_last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Copy the smallest elements of a sequence. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__result_first</td><td>A random-access iterator. </td></tr>
    <tr><td class="paramname">__result_last</td><td>Another random-access iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator indicating the end of the resulting sequence.</dd></dl>
<p>Copies and sorts the smallest N values from the range <code></code>[__first,__last) to the range beginning at <code>__result_first</code>, where the number of elements to be copied, <code>N</code>, is the smaller of <code></code>(__last-__first) and <code></code>(__result_last-__result_first). After the sort if <em>i</em> and <em>j</em> are iterators in the range <code></code>[__result_first,__result_first+N) such that i precedes j then *j&lt;*i is false. The value returned is <code>__result_first+N</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l01737">1737</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gaf53e3f9d5e3c9cd4d36a0801d411e324"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gaf53e3f9d5e3c9cd4d36a0801d411e324">&#9670;&nbsp;</a></span>partial_sort_copy() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _InputIterator , typename _RandomAccessIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">_RandomAccessIterator std::partial_sort_copy </td>
          <td>(</td>
          <td class="paramtype">_InputIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_InputIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__result_first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__result_last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Copy the smallest elements of a sequence using a predicate for comparison. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An input iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another input iterator. </td></tr>
    <tr><td class="paramname">__result_first</td><td>A random-access iterator. </td></tr>
    <tr><td class="paramname">__result_last</td><td>Another random-access iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>An iterator indicating the end of the resulting sequence.</dd></dl>
<p>Copies and sorts the smallest N values from the range <code></code>[__first,__last) to the range beginning at <code>result_first</code>, where the number of elements to be copied, <code>N</code>, is the smaller of <code></code>(__last-__first) and <code></code>(__result_last-__result_first). After the sort if <em>i</em> and <em>j</em> are iterators in the range <code></code>[__result_first,__result_first+N) such that i precedes j then <code>__comp(*j,*i)</code> is false. The value returned is <code>__result_first+N</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l01787">1787</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga0b0e35a43f5f87ea1c66363be3a34619"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga0b0e35a43f5f87ea1c66363be3a34619">&#9670;&nbsp;</a></span>prev_permutation() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::prev_permutation </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Permute range into the previous <em>dictionary</em> ordering. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>False if wrapped to last permutation, true otherwise.</dd></dl>
<p>Treats all permutations of the range as a set of <em>dictionary</em> sorted sequences. Permutes the current sequence into the previous one of this set. Returns true if there are more sequences to generate. If the sequence is the smallest of the set, the largest is generated and false returned. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03054">3054</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga44e9b1d39001f68fa9fcb408b25a77f0"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga44e9b1d39001f68fa9fcb408b25a77f0">&#9670;&nbsp;</a></span>prev_permutation() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _BidirectionalIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">bool std::prev_permutation </td>
          <td>(</td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_BidirectionalIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Permute range into the previous <em>dictionary</em> ordering using comparison functor. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>Start of range. </td></tr>
    <tr><td class="paramname">__last</td><td>End of range. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>False if wrapped to last permutation, true otherwise.</dd></dl>
<p>Treats all permutations of the range [__first,__last) as a set of <em>dictionary</em> sorted sequences ordered by <code>__comp</code>. Permutes the current sequence into the previous one of this set. Returns true if there are more sequences to generate. If the sequence is the smallest of the set, the largest is generated and false returned. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l03086">3086</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga4ea03048647c50ea7cbdd5da30e82755"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga4ea03048647c50ea7cbdd5da30e82755">&#9670;&nbsp;</a></span>sort() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the elements of a sequence. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the elements in the range <code></code>[__first,__last) in ascending order, such that for each iterator <em>i</em> in the range <code></code>[__first,__last-1), *(i+1)&lt;*i is false.</p>
<p>The relative ordering of equivalent elements is not preserved, use <code>stable_sort()</code> if this is needed. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04824">4824</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="gae3c0067ae83db1824367ded659a960b2"></a>
<h2 class="memtitle"><span class="permalink"><a href="#gae3c0067ae83db1824367ded659a960b2">&#9670;&nbsp;</a></span>sort() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the elements of a sequence using a predicate for comparison. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the elements in the range <code></code>[__first,__last) in ascending order, such that <code>__comp</code>(*(i+1),*i) is false for every iterator <em>i</em> in the range <code></code>[__first,__last-1).</p>
<p>The relative ordering of equivalent elements is not preserved, use <code>stable_sort()</code> if this is needed. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l04854">4854</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga7d8bb8e52b7b0e80301dcbec17225b4a"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga7d8bb8e52b7b0e80301dcbec17225b4a">&#9670;&nbsp;</a></span>stable_sort() <span class="overload">[1/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::stable_sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the elements of a sequence, preserving the relative order of equivalent elements. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the elements in the range <code></code>[__first,__last) in ascending order, such that for each iterator <code>i</code> in the range <code></code>[__first,__last-1), <code>*</code>(i+1)&lt;*i is false.</p>
<p>The relative ordering of equivalent elements is preserved, so any two elements <code>x</code> and <code>y</code> in the range <code></code>[__first,__last) such that <code>x&lt;y</code> is false and <code>y&lt;x</code> is false will have the same relative ordering after calling <code>stable_sort()</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05029">5029</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
<a id="ga3a3ce3aa8ac2297f8290939a7988596d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ga3a3ce3aa8ac2297f8290939a7988596d">&#9670;&nbsp;</a></span>stable_sort() <span class="overload">[2/2]</span></h2>

<div class="memitem">
<div class="memproto">
<div class="memtemplate">
template&lt;typename _RandomAccessIterator , typename _Compare &gt; </div>
<table class="mlabels">
  <tr>
  <td class="mlabels-left">
      <table class="memname">
        <tr>
          <td class="memname">void std::stable_sort </td>
          <td>(</td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__first</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_RandomAccessIterator&#160;</td>
          <td class="paramname"><em>__last</em>, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">_Compare&#160;</td>
          <td class="paramname"><em>__comp</em>&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
  </td>
  <td class="mlabels-right">
<span class="mlabels"><span class="mlabel">inline</span></span>  </td>
  </tr>
</table>
</div><div class="memdoc">

<p>Sort the elements of a sequence using a predicate for comparison, preserving the relative order of equivalent elements. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">__first</td><td>An iterator. </td></tr>
    <tr><td class="paramname">__last</td><td>Another iterator. </td></tr>
    <tr><td class="paramname">__comp</td><td>A comparison functor. </td></tr>
  </table>
  </dd>
</dl>
<dl class="section return"><dt>Returns</dt><dd>Nothing.</dd></dl>
<p>Sorts the elements in the range <code></code>[__first,__last) in ascending order, such that for each iterator <code>i</code> in the range <code></code>[__first,__last-1), <code>__comp</code>(*(i+1),*i) is false.</p>
<p>The relative ordering of equivalent elements is preserved, so any two elements <code>x</code> and <code>y</code> in the range <code></code>[__first,__last) such that <code>__comp(x,y)</code> is false and <code>__comp(y,x)</code> is false will have the same relative ordering after calling <code>stable_sort()</code>. </p>

<p class="definition">Definition at line <a class="el" href="a00527_source.html#l05063">5063</a> of file <a class="el" href="a00527_source.html">stl_algo.h</a>.</p>

</div>
</div>
</div><!-- contents -->
</div><!-- doc-content -->
<!-- start footer part -->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
  <ul>
    <li class="footer">Generated by
    <a href="http://www.doxygen.org/index.html">
    <img class="footer" src="doxygen.png" alt="doxygen"/></a> 1.8.15 </li>
  </ul>
</div>
</body>
</html>