1 | // <algorithm> Forward declarations -*- C++ -*- |
---|---|

2 | |

3 | // Copyright (C) 2007-2018 Free Software Foundation, Inc. |

4 | // |

5 | // This file is part of the GNU ISO C++ Library. This library is free |

6 | // software; you can redistribute it and/or modify it under the |

7 | // terms of the GNU General Public License as published by the |

8 | // Free Software Foundation; either version 3, or (at your option) |

9 | // any later version. |

10 | |

11 | // This library is distributed in the hope that it will be useful, |

12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |

13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |

14 | // GNU General Public License for more details. |

15 | |

16 | // Under Section 7 of GPL version 3, you are granted additional |

17 | // permissions described in the GCC Runtime Library Exception, version |

18 | // 3.1, as published by the Free Software Foundation. |

19 | |

20 | // You should have received a copy of the GNU General Public License and |

21 | // a copy of the GCC Runtime Library Exception along with this program; |

22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |

23 | // <http://www.gnu.org/licenses/>. |

24 | |

25 | /** @file bits/algorithmfwd.h |

26 | * This is an internal header file, included by other library headers. |

27 | * Do not attempt to use it directly. @headername{algorithm} |

28 | */ |

29 | |

30 | #ifndef _GLIBCXX_ALGORITHMFWD_H |

31 | #define _GLIBCXX_ALGORITHMFWD_H 1 |

32 | |

33 | #pragma GCC system_header |

34 | |

35 | #include <bits/c++config.h> |

36 | #include <bits/stl_pair.h> |

37 | #include <bits/stl_iterator_base_types.h> |

38 | #if __cplusplus >= 201103L |

39 | #include <initializer_list> |

40 | #endif |

41 | |

42 | namespace std _GLIBCXX_VISIBILITY(default) |

43 | { |

44 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |

45 | |

46 | /* |

47 | adjacent_find |

48 | all_of (C++11) |

49 | any_of (C++11) |

50 | binary_search |

51 | clamp (C++17) |

52 | copy |

53 | copy_backward |

54 | copy_if (C++11) |

55 | copy_n (C++11) |

56 | count |

57 | count_if |

58 | equal |

59 | equal_range |

60 | fill |

61 | fill_n |

62 | find |

63 | find_end |

64 | find_first_of |

65 | find_if |

66 | find_if_not (C++11) |

67 | for_each |

68 | generate |

69 | generate_n |

70 | includes |

71 | inplace_merge |

72 | is_heap (C++11) |

73 | is_heap_until (C++11) |

74 | is_partitioned (C++11) |

75 | is_sorted (C++11) |

76 | is_sorted_until (C++11) |

77 | iter_swap |

78 | lexicographical_compare |

79 | lower_bound |

80 | make_heap |

81 | max |

82 | max_element |

83 | merge |

84 | min |

85 | min_element |

86 | minmax (C++11) |

87 | minmax_element (C++11) |

88 | mismatch |

89 | next_permutation |

90 | none_of (C++11) |

91 | nth_element |

92 | partial_sort |

93 | partial_sort_copy |

94 | partition |

95 | partition_copy (C++11) |

96 | partition_point (C++11) |

97 | pop_heap |

98 | prev_permutation |

99 | push_heap |

100 | random_shuffle |

101 | remove |

102 | remove_copy |

103 | remove_copy_if |

104 | remove_if |

105 | replace |

106 | replace_copy |

107 | replace_copy_if |

108 | replace_if |

109 | reverse |

110 | reverse_copy |

111 | rotate |

112 | rotate_copy |

113 | search |

114 | search_n |

115 | set_difference |

116 | set_intersection |

117 | set_symmetric_difference |

118 | set_union |

119 | shuffle (C++11) |

120 | sort |

121 | sort_heap |

122 | stable_partition |

123 | stable_sort |

124 | swap |

125 | swap_ranges |

126 | transform |

127 | unique |

128 | unique_copy |

129 | upper_bound |

130 | */ |

131 | |

132 | /** |

133 | * @defgroup algorithms Algorithms |

134 | * |

135 | * Components for performing algorithmic operations. Includes |

136 | * non-modifying sequence, modifying (mutating) sequence, sorting, |

137 | * searching, merge, partition, heap, set, minima, maxima, and |

138 | * permutation operations. |

139 | */ |

140 | |

141 | /** |

142 | * @defgroup mutating_algorithms Mutating |

143 | * @ingroup algorithms |

144 | */ |

145 | |

146 | /** |

147 | * @defgroup non_mutating_algorithms Non-Mutating |

148 | * @ingroup algorithms |

149 | */ |

150 | |

151 | /** |

152 | * @defgroup sorting_algorithms Sorting |

153 | * @ingroup algorithms |

154 | */ |

155 | |

156 | /** |

157 | * @defgroup set_algorithms Set Operation |

158 | * @ingroup sorting_algorithms |

159 | * |

160 | * These algorithms are common set operations performed on sequences |

161 | * that are already sorted. The number of comparisons will be |

162 | * linear. |

163 | */ |

164 | |

165 | /** |

166 | * @defgroup binary_search_algorithms Binary Search |

167 | * @ingroup sorting_algorithms |

168 | * |

169 | * These algorithms are variations of a classic binary search, and |

170 | * all assume that the sequence being searched is already sorted. |

171 | * |

172 | * The number of comparisons will be logarithmic (and as few as |

173 | * possible). The number of steps through the sequence will be |

174 | * logarithmic for random-access iterators (e.g., pointers), and |

175 | * linear otherwise. |

176 | * |

177 | * The LWG has passed Defect Report 270, which notes: <em>The |

178 | * proposed resolution reinterprets binary search. Instead of |

179 | * thinking about searching for a value in a sorted range, we view |

180 | * that as an important special case of a more general algorithm: |

181 | * searching for the partition point in a partitioned range. We |

182 | * also add a guarantee that the old wording did not: we ensure that |

183 | * the upper bound is no earlier than the lower bound, that the pair |

184 | * returned by equal_range is a valid range, and that the first part |

185 | * of that pair is the lower bound.</em> |

186 | * |

187 | * The actual effect of the first sentence is that a comparison |

188 | * functor passed by the user doesn't necessarily need to induce a |

189 | * strict weak ordering relation. Rather, it partitions the range. |

190 | */ |

191 | |

192 | // adjacent_find |

193 | |

194 | #if __cplusplus >= 201103L |

195 | template<typename _IIter, typename _Predicate> |

196 | bool |

197 | all_of(_IIter, _IIter, _Predicate); |

198 | |

199 | template<typename _IIter, typename _Predicate> |

200 | bool |

201 | any_of(_IIter, _IIter, _Predicate); |

202 | #endif |

203 | |

204 | template<typename _FIter, typename _Tp> |

205 | bool |

206 | binary_search(_FIter, _FIter, const _Tp&); |

207 | |

208 | template<typename _FIter, typename _Tp, typename _Compare> |

209 | bool |

210 | binary_search(_FIter, _FIter, const _Tp&, _Compare); |

211 | |

212 | #if __cplusplus > 201402L |

213 | template<typename _Tp> |

214 | _GLIBCXX14_CONSTEXPR |

215 | const _Tp& |

216 | clamp(const _Tp&, const _Tp&, const _Tp&); |

217 | |

218 | template<typename _Tp, typename _Compare> |

219 | _GLIBCXX14_CONSTEXPR |

220 | const _Tp& |

221 | clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); |

222 | #endif |

223 | |

224 | template<typename _IIter, typename _OIter> |

225 | _OIter |

226 | copy(_IIter, _IIter, _OIter); |

227 | |

228 | template<typename _BIter1, typename _BIter2> |

229 | _BIter2 |

230 | copy_backward(_BIter1, _BIter1, _BIter2); |

231 | |

232 | #if __cplusplus >= 201103L |

233 | template<typename _IIter, typename _OIter, typename _Predicate> |

234 | _OIter |

235 | copy_if(_IIter, _IIter, _OIter, _Predicate); |

236 | |

237 | template<typename _IIter, typename _Size, typename _OIter> |

238 | _OIter |

239 | copy_n(_IIter, _Size, _OIter); |

240 | #endif |

241 | |

242 | // count |

243 | // count_if |

244 | |

245 | template<typename _FIter, typename _Tp> |

246 | pair<_FIter, _FIter> |

247 | equal_range(_FIter, _FIter, const _Tp&); |

248 | |

249 | template<typename _FIter, typename _Tp, typename _Compare> |

250 | pair<_FIter, _FIter> |

251 | equal_range(_FIter, _FIter, const _Tp&, _Compare); |

252 | |

253 | template<typename _FIter, typename _Tp> |

254 | void |

255 | fill(_FIter, _FIter, const _Tp&); |

256 | |

257 | template<typename _OIter, typename _Size, typename _Tp> |

258 | _OIter |

259 | fill_n(_OIter, _Size, const _Tp&); |

260 | |

261 | // find |

262 | |

263 | template<typename _FIter1, typename _FIter2> |

264 | _FIter1 |

265 | find_end(_FIter1, _FIter1, _FIter2, _FIter2); |

266 | |

267 | template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> |

268 | _FIter1 |

269 | find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); |

270 | |

271 | // find_first_of |

272 | // find_if |

273 | |

274 | #if __cplusplus >= 201103L |

275 | template<typename _IIter, typename _Predicate> |

276 | _IIter |

277 | find_if_not(_IIter, _IIter, _Predicate); |

278 | #endif |

279 | |

280 | // for_each |

281 | // generate |

282 | // generate_n |

283 | |

284 | template<typename _IIter1, typename _IIter2> |

285 | bool |

286 | includes(_IIter1, _IIter1, _IIter2, _IIter2); |

287 | |

288 | template<typename _IIter1, typename _IIter2, typename _Compare> |

289 | bool |

290 | includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); |

291 | |

292 | template<typename _BIter> |

293 | void |

294 | inplace_merge(_BIter, _BIter, _BIter); |

295 | |

296 | template<typename _BIter, typename _Compare> |

297 | void |

298 | inplace_merge(_BIter, _BIter, _BIter, _Compare); |

299 | |

300 | #if __cplusplus >= 201103L |

301 | template<typename _RAIter> |

302 | bool |

303 | is_heap(_RAIter, _RAIter); |

304 | |

305 | template<typename _RAIter, typename _Compare> |

306 | bool |

307 | is_heap(_RAIter, _RAIter, _Compare); |

308 | |

309 | template<typename _RAIter> |

310 | _RAIter |

311 | is_heap_until(_RAIter, _RAIter); |

312 | |

313 | template<typename _RAIter, typename _Compare> |

314 | _RAIter |

315 | is_heap_until(_RAIter, _RAIter, _Compare); |

316 | |

317 | template<typename _IIter, typename _Predicate> |

318 | bool |

319 | is_partitioned(_IIter, _IIter, _Predicate); |

320 | |

321 | template<typename _FIter1, typename _FIter2> |

322 | bool |

323 | is_permutation(_FIter1, _FIter1, _FIter2); |

324 | |

325 | template<typename _FIter1, typename _FIter2, |

326 | typename _BinaryPredicate> |

327 | bool |

328 | is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); |

329 | |

330 | template<typename _FIter> |

331 | bool |

332 | is_sorted(_FIter, _FIter); |

333 | |

334 | template<typename _FIter, typename _Compare> |

335 | bool |

336 | is_sorted(_FIter, _FIter, _Compare); |

337 | |

338 | template<typename _FIter> |

339 | _FIter |

340 | is_sorted_until(_FIter, _FIter); |

341 | |

342 | template<typename _FIter, typename _Compare> |

343 | _FIter |

344 | is_sorted_until(_FIter, _FIter, _Compare); |

345 | #endif |

346 | |

347 | template<typename _FIter1, typename _FIter2> |

348 | void |

349 | iter_swap(_FIter1, _FIter2); |

350 | |

351 | template<typename _FIter, typename _Tp> |

352 | _FIter |

353 | lower_bound(_FIter, _FIter, const _Tp&); |

354 | |

355 | template<typename _FIter, typename _Tp, typename _Compare> |

356 | _FIter |

357 | lower_bound(_FIter, _FIter, const _Tp&, _Compare); |

358 | |

359 | template<typename _RAIter> |

360 | void |

361 | make_heap(_RAIter, _RAIter); |

362 | |

363 | template<typename _RAIter, typename _Compare> |

364 | void |

365 | make_heap(_RAIter, _RAIter, _Compare); |

366 | |

367 | template<typename _Tp> |

368 | _GLIBCXX14_CONSTEXPR |

369 | const _Tp& |

370 | max(const _Tp&, const _Tp&); |

371 | |

372 | template<typename _Tp, typename _Compare> |

373 | _GLIBCXX14_CONSTEXPR |

374 | const _Tp& |

375 | max(const _Tp&, const _Tp&, _Compare); |

376 | |

377 | // max_element |

378 | // merge |

379 | |

380 | template<typename _Tp> |

381 | _GLIBCXX14_CONSTEXPR |

382 | const _Tp& |

383 | min(const _Tp&, const _Tp&); |

384 | |

385 | template<typename _Tp, typename _Compare> |

386 | _GLIBCXX14_CONSTEXPR |

387 | const _Tp& |

388 | min(const _Tp&, const _Tp&, _Compare); |

389 | |

390 | // min_element |

391 | |

392 | #if __cplusplus >= 201103L |

393 | template<typename _Tp> |

394 | _GLIBCXX14_CONSTEXPR |

395 | pair<const _Tp&, const _Tp&> |

396 | minmax(const _Tp&, const _Tp&); |

397 | |

398 | template<typename _Tp, typename _Compare> |

399 | _GLIBCXX14_CONSTEXPR |

400 | pair<const _Tp&, const _Tp&> |

401 | minmax(const _Tp&, const _Tp&, _Compare); |

402 | |

403 | template<typename _FIter> |

404 | _GLIBCXX14_CONSTEXPR |

405 | pair<_FIter, _FIter> |

406 | minmax_element(_FIter, _FIter); |

407 | |

408 | template<typename _FIter, typename _Compare> |

409 | _GLIBCXX14_CONSTEXPR |

410 | pair<_FIter, _FIter> |

411 | minmax_element(_FIter, _FIter, _Compare); |

412 | |

413 | template<typename _Tp> |

414 | _GLIBCXX14_CONSTEXPR |

415 | _Tp |

416 | min(initializer_list<_Tp>); |

417 | |

418 | template<typename _Tp, typename _Compare> |

419 | _GLIBCXX14_CONSTEXPR |

420 | _Tp |

421 | min(initializer_list<_Tp>, _Compare); |

422 | |

423 | template<typename _Tp> |

424 | _GLIBCXX14_CONSTEXPR |

425 | _Tp |

426 | max(initializer_list<_Tp>); |

427 | |

428 | template<typename _Tp, typename _Compare> |

429 | _GLIBCXX14_CONSTEXPR |

430 | _Tp |

431 | max(initializer_list<_Tp>, _Compare); |

432 | |

433 | template<typename _Tp> |

434 | _GLIBCXX14_CONSTEXPR |

435 | pair<_Tp, _Tp> |

436 | minmax(initializer_list<_Tp>); |

437 | |

438 | template<typename _Tp, typename _Compare> |

439 | _GLIBCXX14_CONSTEXPR |

440 | pair<_Tp, _Tp> |

441 | minmax(initializer_list<_Tp>, _Compare); |

442 | #endif |

443 | |

444 | // mismatch |

445 | |

446 | template<typename _BIter> |

447 | bool |

448 | next_permutation(_BIter, _BIter); |

449 | |

450 | template<typename _BIter, typename _Compare> |

451 | bool |

452 | next_permutation(_BIter, _BIter, _Compare); |

453 | |

454 | #if __cplusplus >= 201103L |

455 | template<typename _IIter, typename _Predicate> |

456 | bool |

457 | none_of(_IIter, _IIter, _Predicate); |

458 | #endif |

459 | |

460 | // nth_element |

461 | // partial_sort |

462 | |

463 | template<typename _IIter, typename _RAIter> |

464 | _RAIter |

465 | partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); |

466 | |

467 | template<typename _IIter, typename _RAIter, typename _Compare> |

468 | _RAIter |

469 | partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); |

470 | |

471 | // partition |

472 | |

473 | #if __cplusplus >= 201103L |

474 | template<typename _IIter, typename _OIter1, |

475 | typename _OIter2, typename _Predicate> |

476 | pair<_OIter1, _OIter2> |

477 | partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); |

478 | |

479 | template<typename _FIter, typename _Predicate> |

480 | _FIter |

481 | partition_point(_FIter, _FIter, _Predicate); |

482 | #endif |

483 | |

484 | template<typename _RAIter> |

485 | void |

486 | pop_heap(_RAIter, _RAIter); |

487 | |

488 | template<typename _RAIter, typename _Compare> |

489 | void |

490 | pop_heap(_RAIter, _RAIter, _Compare); |

491 | |

492 | template<typename _BIter> |

493 | bool |

494 | prev_permutation(_BIter, _BIter); |

495 | |

496 | template<typename _BIter, typename _Compare> |

497 | bool |

498 | prev_permutation(_BIter, _BIter, _Compare); |

499 | |

500 | template<typename _RAIter> |

501 | void |

502 | push_heap(_RAIter, _RAIter); |

503 | |

504 | template<typename _RAIter, typename _Compare> |

505 | void |

506 | push_heap(_RAIter, _RAIter, _Compare); |

507 | |

508 | // random_shuffle |

509 | |

510 | template<typename _FIter, typename _Tp> |

511 | _FIter |

512 | remove(_FIter, _FIter, const _Tp&); |

513 | |

514 | template<typename _FIter, typename _Predicate> |

515 | _FIter |

516 | remove_if(_FIter, _FIter, _Predicate); |

517 | |

518 | template<typename _IIter, typename _OIter, typename _Tp> |

519 | _OIter |

520 | remove_copy(_IIter, _IIter, _OIter, const _Tp&); |

521 | |

522 | template<typename _IIter, typename _OIter, typename _Predicate> |

523 | _OIter |

524 | remove_copy_if(_IIter, _IIter, _OIter, _Predicate); |

525 | |

526 | // replace |

527 | |

528 | template<typename _IIter, typename _OIter, typename _Tp> |

529 | _OIter |

530 | replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); |

531 | |

532 | template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> |

533 | _OIter |

534 | replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); |

535 | |

536 | // replace_if |

537 | |

538 | template<typename _BIter> |

539 | void |

540 | reverse(_BIter, _BIter); |

541 | |

542 | template<typename _BIter, typename _OIter> |

543 | _OIter |

544 | reverse_copy(_BIter, _BIter, _OIter); |

545 | |

546 | inline namespace _V2 |

547 | { |

548 | template<typename _FIter> |

549 | _FIter |

550 | rotate(_FIter, _FIter, _FIter); |

551 | } |

552 | |

553 | template<typename _FIter, typename _OIter> |

554 | _OIter |

555 | rotate_copy(_FIter, _FIter, _FIter, _OIter); |

556 | |

557 | // search |

558 | // search_n |

559 | // set_difference |

560 | // set_intersection |

561 | // set_symmetric_difference |

562 | // set_union |

563 | |

564 | #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) |

565 | template<typename _RAIter, typename _UGenerator> |

566 | void |

567 | shuffle(_RAIter, _RAIter, _UGenerator&&); |

568 | #endif |

569 | |

570 | template<typename _RAIter> |

571 | void |

572 | sort_heap(_RAIter, _RAIter); |

573 | |

574 | template<typename _RAIter, typename _Compare> |

575 | void |

576 | sort_heap(_RAIter, _RAIter, _Compare); |

577 | |

578 | template<typename _BIter, typename _Predicate> |

579 | _BIter |

580 | stable_partition(_BIter, _BIter, _Predicate); |

581 | |

582 | #if __cplusplus < 201103L |

583 | // For C++11 swap() is declared in <type_traits>. |

584 | |

585 | template<typename _Tp, size_t _Nm> |

586 | inline void |

587 | swap(_Tp& __a, _Tp& __b); |

588 | |

589 | template<typename _Tp, size_t _Nm> |

590 | inline void |

591 | swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]); |

592 | #endif |

593 | |

594 | template<typename _FIter1, typename _FIter2> |

595 | _FIter2 |

596 | swap_ranges(_FIter1, _FIter1, _FIter2); |

597 | |

598 | // transform |

599 | |

600 | template<typename _FIter> |

601 | _FIter |

602 | unique(_FIter, _FIter); |

603 | |

604 | template<typename _FIter, typename _BinaryPredicate> |

605 | _FIter |

606 | unique(_FIter, _FIter, _BinaryPredicate); |

607 | |

608 | // unique_copy |

609 | |

610 | template<typename _FIter, typename _Tp> |

611 | _FIter |

612 | upper_bound(_FIter, _FIter, const _Tp&); |

613 | |

614 | template<typename _FIter, typename _Tp, typename _Compare> |

615 | _FIter |

616 | upper_bound(_FIter, _FIter, const _Tp&, _Compare); |

617 | |

618 | _GLIBCXX_BEGIN_NAMESPACE_ALGO |

619 | |

620 | template<typename _FIter> |

621 | _FIter |

622 | adjacent_find(_FIter, _FIter); |

623 | |

624 | template<typename _FIter, typename _BinaryPredicate> |

625 | _FIter |

626 | adjacent_find(_FIter, _FIter, _BinaryPredicate); |

627 | |

628 | template<typename _IIter, typename _Tp> |

629 | typename iterator_traits<_IIter>::difference_type |

630 | count(_IIter, _IIter, const _Tp&); |

631 | |

632 | template<typename _IIter, typename _Predicate> |

633 | typename iterator_traits<_IIter>::difference_type |

634 | count_if(_IIter, _IIter, _Predicate); |

635 | |

636 | template<typename _IIter1, typename _IIter2> |

637 | bool |

638 | equal(_IIter1, _IIter1, _IIter2); |

639 | |

640 | template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> |

641 | bool |

642 | equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); |

643 | |

644 | template<typename _IIter, typename _Tp> |

645 | _IIter |

646 | find(_IIter, _IIter, const _Tp&); |

647 | |

648 | template<typename _FIter1, typename _FIter2> |

649 | _FIter1 |

650 | find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); |

651 | |

652 | template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> |

653 | _FIter1 |

654 | find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); |

655 | |

656 | template<typename _IIter, typename _Predicate> |

657 | _IIter |

658 | find_if(_IIter, _IIter, _Predicate); |

659 | |

660 | template<typename _IIter, typename _Funct> |

661 | _Funct |

662 | for_each(_IIter, _IIter, _Funct); |

663 | |

664 | template<typename _FIter, typename _Generator> |

665 | void |

666 | generate(_FIter, _FIter, _Generator); |

667 | |

668 | template<typename _OIter, typename _Size, typename _Generator> |

669 | _OIter |

670 | generate_n(_OIter, _Size, _Generator); |

671 | |

672 | template<typename _IIter1, typename _IIter2> |

673 | bool |

674 | lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); |

675 | |

676 | template<typename _IIter1, typename _IIter2, typename _Compare> |

677 | bool |

678 | lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); |

679 | |

680 | template<typename _FIter> |

681 | _GLIBCXX14_CONSTEXPR |

682 | _FIter |

683 | max_element(_FIter, _FIter); |

684 | |

685 | template<typename _FIter, typename _Compare> |

686 | _GLIBCXX14_CONSTEXPR |

687 | _FIter |

688 | max_element(_FIter, _FIter, _Compare); |

689 | |

690 | template<typename _IIter1, typename _IIter2, typename _OIter> |

691 | _OIter |

692 | merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); |

693 | |

694 | template<typename _IIter1, typename _IIter2, typename _OIter, |

695 | typename _Compare> |

696 | _OIter |

697 | merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); |

698 | |

699 | template<typename _FIter> |

700 | _GLIBCXX14_CONSTEXPR |

701 | _FIter |

702 | min_element(_FIter, _FIter); |

703 | |

704 | template<typename _FIter, typename _Compare> |

705 | _GLIBCXX14_CONSTEXPR |

706 | _FIter |

707 | min_element(_FIter, _FIter, _Compare); |

708 | |

709 | template<typename _IIter1, typename _IIter2> |

710 | pair<_IIter1, _IIter2> |

711 | mismatch(_IIter1, _IIter1, _IIter2); |

712 | |

713 | template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> |

714 | pair<_IIter1, _IIter2> |

715 | mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); |

716 | |

717 | template<typename _RAIter> |

718 | void |

719 | nth_element(_RAIter, _RAIter, _RAIter); |

720 | |

721 | template<typename _RAIter, typename _Compare> |

722 | void |

723 | nth_element(_RAIter, _RAIter, _RAIter, _Compare); |

724 | |

725 | template<typename _RAIter> |

726 | void |

727 | partial_sort(_RAIter, _RAIter, _RAIter); |

728 | |

729 | template<typename _RAIter, typename _Compare> |

730 | void |

731 | partial_sort(_RAIter, _RAIter, _RAIter, _Compare); |

732 | |

733 | template<typename _BIter, typename _Predicate> |

734 | _BIter |

735 | partition(_BIter, _BIter, _Predicate); |

736 | |

737 | template<typename _RAIter> |

738 | void |

739 | random_shuffle(_RAIter, _RAIter); |

740 | |

741 | template<typename _RAIter, typename _Generator> |

742 | void |

743 | random_shuffle(_RAIter, _RAIter, |

744 | #if __cplusplus >= 201103L |

745 | _Generator&&); |

746 | #else |

747 | _Generator&); |

748 | #endif |

749 | |

750 | template<typename _FIter, typename _Tp> |

751 | void |

752 | replace(_FIter, _FIter, const _Tp&, const _Tp&); |

753 | |

754 | template<typename _FIter, typename _Predicate, typename _Tp> |

755 | void |

756 | replace_if(_FIter, _FIter, _Predicate, const _Tp&); |

757 | |

758 | template<typename _FIter1, typename _FIter2> |

759 | _FIter1 |

760 | search(_FIter1, _FIter1, _FIter2, _FIter2); |

761 | |

762 | template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> |

763 | _FIter1 |

764 | search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); |

765 | |

766 | template<typename _FIter, typename _Size, typename _Tp> |

767 | _FIter |

768 | search_n(_FIter, _FIter, _Size, const _Tp&); |

769 | |

770 | template<typename _FIter, typename _Size, typename _Tp, |

771 | typename _BinaryPredicate> |

772 | _FIter |

773 | search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); |

774 | |

775 | template<typename _IIter1, typename _IIter2, typename _OIter> |

776 | _OIter |

777 | set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); |

778 | |

779 | template<typename _IIter1, typename _IIter2, typename _OIter, |

780 | typename _Compare> |

781 | _OIter |

782 | set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); |

783 | |

784 | template<typename _IIter1, typename _IIter2, typename _OIter> |

785 | _OIter |

786 | set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); |

787 | |

788 | template<typename _IIter1, typename _IIter2, typename _OIter, |

789 | typename _Compare> |

790 | _OIter |

791 | set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); |

792 | |

793 | template<typename _IIter1, typename _IIter2, typename _OIter> |

794 | _OIter |

795 | set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); |

796 | |

797 | template<typename _IIter1, typename _IIter2, typename _OIter, |

798 | typename _Compare> |

799 | _OIter |

800 | set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, |

801 | _OIter, _Compare); |

802 | |

803 | template<typename _IIter1, typename _IIter2, typename _OIter> |

804 | _OIter |

805 | set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); |

806 | |

807 | template<typename _IIter1, typename _IIter2, typename _OIter, |

808 | typename _Compare> |

809 | _OIter |

810 | set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); |

811 | |

812 | template<typename _RAIter> |

813 | void |

814 | sort(_RAIter, _RAIter); |

815 | |

816 | template<typename _RAIter, typename _Compare> |

817 | void |

818 | sort(_RAIter, _RAIter, _Compare); |

819 | |

820 | template<typename _RAIter> |

821 | void |

822 | stable_sort(_RAIter, _RAIter); |

823 | |

824 | template<typename _RAIter, typename _Compare> |

825 | void |

826 | stable_sort(_RAIter, _RAIter, _Compare); |

827 | |

828 | template<typename _IIter, typename _OIter, typename _UnaryOperation> |

829 | _OIter |

830 | transform(_IIter, _IIter, _OIter, _UnaryOperation); |

831 | |

832 | template<typename _IIter1, typename _IIter2, typename _OIter, |

833 | typename _BinaryOperation> |

834 | _OIter |

835 | transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); |

836 | |

837 | template<typename _IIter, typename _OIter> |

838 | _OIter |

839 | unique_copy(_IIter, _IIter, _OIter); |

840 | |

841 | template<typename _IIter, typename _OIter, typename _BinaryPredicate> |

842 | _OIter |

843 | unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); |

844 | |

845 | _GLIBCXX_END_NAMESPACE_ALGO |

846 | _GLIBCXX_END_NAMESPACE_VERSION |

847 | } // namespace std |

848 | |

849 | #ifdef _GLIBCXX_PARALLEL |

850 | # include <parallel/algorithmfwd.h> |

851 | #endif |

852 | |

853 | #endif |

854 | |

855 |