1 // Heap implementation -*- C++ -*-
3 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 // Free Software Foundation, Inc.
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 3, or (at your option)
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
29 * Hewlett-Packard Company
31 * Permission to use, copy, modify, distribute and sell this software
32 * and its documentation for any purpose is hereby granted without fee,
33 * provided that the above copyright notice appear in all copies and
34 * that both that copyright notice and this permission notice appear
35 * in supporting documentation. Hewlett-Packard Company makes no
36 * representations about the suitability of this software for any
37 * purpose. It is provided "as is" without express or implied warranty.
40 * Silicon Graphics Computer Systems, Inc.
42 * Permission to use, copy, modify, distribute and sell this software
43 * and its documentation for any purpose is hereby granted without fee,
44 * provided that the above copyright notice appear in all copies and
45 * that both that copyright notice and this permission notice appear
46 * in supporting documentation. Silicon Graphics makes no
47 * representations about the suitability of this software for any
48 * purpose. It is provided "as is" without express or implied warranty.
52 * This is an internal header file, included by other library headers.
53 * You should not attempt to use it directly.
59 #include <debug/debug.h>
60 #include <bits/move.h>
62 _GLIBCXX_BEGIN_NAMESPACE(std)
65 * @defgroup heap_algorithms Heap Algorithms
66 * @ingroup sorting_algorithms
69 template<typename _RandomAccessIterator, typename _Distance>
71 __is_heap_until(_RandomAccessIterator __first, _Distance __n)
73 _Distance __parent = 0;
74 for (_Distance __child = 1; __child < __n; ++__child)
76 if (__first[__parent] < __first[__child])
78 if ((__child & 1) == 0)
84 template<typename _RandomAccessIterator, typename _Distance,
87 __is_heap_until(_RandomAccessIterator __first, _Distance __n,
90 _Distance __parent = 0;
91 for (_Distance __child = 1; __child < __n; ++__child)
93 if (__comp(__first[__parent], __first[__child]))
95 if ((__child & 1) == 0)
101 // __is_heap, a predicate testing whether or not a range is a heap.
102 // This function is an extension, not part of the C++ standard.
103 template<typename _RandomAccessIterator, typename _Distance>
105 __is_heap(_RandomAccessIterator __first, _Distance __n)
106 { return std::__is_heap_until(__first, __n) == __n; }
108 template<typename _RandomAccessIterator, typename _Compare,
111 __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
112 { return std::__is_heap_until(__first, __n, __comp) == __n; }
114 template<typename _RandomAccessIterator>
116 __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
117 { return std::__is_heap(__first, std::distance(__first, __last)); }
119 template<typename _RandomAccessIterator, typename _Compare>
121 __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
123 { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
125 // Heap-manipulation functions: push_heap, pop_heap, make_heap, sort_heap,
126 // + is_heap and is_heap_until in C++0x.
128 template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
130 __push_heap(_RandomAccessIterator __first,
131 _Distance __holeIndex, _Distance __topIndex, _Tp __value)
133 _Distance __parent = (__holeIndex - 1) / 2;
134 while (__holeIndex > __topIndex && *(__first + __parent) < __value)
136 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
137 __holeIndex = __parent;
138 __parent = (__holeIndex - 1) / 2;
140 *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
144 * @brief Push an element onto a heap.
145 * @param first Start of heap.
146 * @param last End of heap + element.
147 * @ingroup heap_algorithms
149 * This operation pushes the element at last-1 onto the valid heap over the
150 * range [first,last-1). After completion, [first,last) is a valid heap.
152 template<typename _RandomAccessIterator>
154 push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
156 typedef typename iterator_traits<_RandomAccessIterator>::value_type
158 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
161 // concept requirements
162 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
163 _RandomAccessIterator>)
164 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
165 __glibcxx_requires_valid_range(__first, __last);
166 __glibcxx_requires_heap(__first, __last - 1);
168 _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
169 std::__push_heap(__first, _DistanceType((__last - __first) - 1),
170 _DistanceType(0), _GLIBCXX_MOVE(__value));
173 template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
176 __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
177 _Distance __topIndex, _Tp __value, _Compare __comp)
179 _Distance __parent = (__holeIndex - 1) / 2;
180 while (__holeIndex > __topIndex
181 && __comp(*(__first + __parent), __value))
183 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __parent));
184 __holeIndex = __parent;
185 __parent = (__holeIndex - 1) / 2;
187 *(__first + __holeIndex) = _GLIBCXX_MOVE(__value);
191 * @brief Push an element onto a heap using comparison functor.
192 * @param first Start of heap.
193 * @param last End of heap + element.
194 * @param comp Comparison functor.
195 * @ingroup heap_algorithms
197 * This operation pushes the element at last-1 onto the valid heap over the
198 * range [first,last-1). After completion, [first,last) is a valid heap.
199 * Compare operations are performed using comp.
201 template<typename _RandomAccessIterator, typename _Compare>
203 push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
206 typedef typename iterator_traits<_RandomAccessIterator>::value_type
208 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
211 // concept requirements
212 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
213 _RandomAccessIterator>)
214 __glibcxx_requires_valid_range(__first, __last);
215 __glibcxx_requires_heap_pred(__first, __last - 1, __comp);
217 _ValueType __value = _GLIBCXX_MOVE(*(__last - 1));
218 std::__push_heap(__first, _DistanceType((__last - __first) - 1),
219 _DistanceType(0), _GLIBCXX_MOVE(__value), __comp);
222 template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
224 __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
225 _Distance __len, _Tp __value)
227 const _Distance __topIndex = __holeIndex;
228 _Distance __secondChild = __holeIndex;
229 while (__secondChild < (__len - 1) / 2)
231 __secondChild = 2 * (__secondChild + 1);
232 if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
234 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
235 __holeIndex = __secondChild;
237 if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
239 __secondChild = 2 * (__secondChild + 1);
240 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
241 + (__secondChild - 1)));
242 __holeIndex = __secondChild - 1;
244 std::__push_heap(__first, __holeIndex, __topIndex,
245 _GLIBCXX_MOVE(__value));
248 template<typename _RandomAccessIterator>
250 __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
251 _RandomAccessIterator __result)
253 typedef typename iterator_traits<_RandomAccessIterator>::value_type
255 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
258 _ValueType __value = _GLIBCXX_MOVE(*__result);
259 *__result = _GLIBCXX_MOVE(*__first);
260 std::__adjust_heap(__first, _DistanceType(0),
261 _DistanceType(__last - __first),
262 _GLIBCXX_MOVE(__value));
266 * @brief Pop an element off a heap.
267 * @param first Start of heap.
268 * @param last End of heap.
269 * @ingroup heap_algorithms
271 * This operation pops the top of the heap. The elements first and last-1
272 * are swapped and [first,last-1) is made into a heap.
274 template<typename _RandomAccessIterator>
276 pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
278 typedef typename iterator_traits<_RandomAccessIterator>::value_type
281 // concept requirements
282 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
283 _RandomAccessIterator>)
284 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
285 __glibcxx_requires_valid_range(__first, __last);
286 __glibcxx_requires_heap(__first, __last);
289 std::__pop_heap(__first, __last, __last);
292 template<typename _RandomAccessIterator, typename _Distance,
293 typename _Tp, typename _Compare>
295 __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
296 _Distance __len, _Tp __value, _Compare __comp)
298 const _Distance __topIndex = __holeIndex;
299 _Distance __secondChild = __holeIndex;
300 while (__secondChild < (__len - 1) / 2)
302 __secondChild = 2 * (__secondChild + 1);
303 if (__comp(*(__first + __secondChild),
304 *(__first + (__secondChild - 1))))
306 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first + __secondChild));
307 __holeIndex = __secondChild;
309 if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
311 __secondChild = 2 * (__secondChild + 1);
312 *(__first + __holeIndex) = _GLIBCXX_MOVE(*(__first
313 + (__secondChild - 1)));
314 __holeIndex = __secondChild - 1;
316 std::__push_heap(__first, __holeIndex, __topIndex,
317 _GLIBCXX_MOVE(__value), __comp);
320 template<typename _RandomAccessIterator, typename _Compare>
322 __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
323 _RandomAccessIterator __result, _Compare __comp)
325 typedef typename iterator_traits<_RandomAccessIterator>::value_type
327 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
330 _ValueType __value = _GLIBCXX_MOVE(*__result);
331 *__result = _GLIBCXX_MOVE(*__first);
332 std::__adjust_heap(__first, _DistanceType(0),
333 _DistanceType(__last - __first),
334 _GLIBCXX_MOVE(__value), __comp);
338 * @brief Pop an element off a heap using comparison functor.
339 * @param first Start of heap.
340 * @param last End of heap.
341 * @param comp Comparison functor to use.
342 * @ingroup heap_algorithms
344 * This operation pops the top of the heap. The elements first and last-1
345 * are swapped and [first,last-1) is made into a heap. Comparisons are
348 template<typename _RandomAccessIterator, typename _Compare>
350 pop_heap(_RandomAccessIterator __first,
351 _RandomAccessIterator __last, _Compare __comp)
353 // concept requirements
354 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
355 _RandomAccessIterator>)
356 __glibcxx_requires_valid_range(__first, __last);
357 __glibcxx_requires_heap_pred(__first, __last, __comp);
360 std::__pop_heap(__first, __last, __last, __comp);
364 * @brief Construct a heap over a range.
365 * @param first Start of heap.
366 * @param last End of heap.
367 * @ingroup heap_algorithms
369 * This operation makes the elements in [first,last) into a heap.
371 template<typename _RandomAccessIterator>
373 make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
375 typedef typename iterator_traits<_RandomAccessIterator>::value_type
377 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
380 // concept requirements
381 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
382 _RandomAccessIterator>)
383 __glibcxx_function_requires(_LessThanComparableConcept<_ValueType>)
384 __glibcxx_requires_valid_range(__first, __last);
386 if (__last - __first < 2)
389 const _DistanceType __len = __last - __first;
390 _DistanceType __parent = (__len - 2) / 2;
393 _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
394 std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value));
402 * @brief Construct a heap over a range using comparison functor.
403 * @param first Start of heap.
404 * @param last End of heap.
405 * @param comp Comparison functor to use.
406 * @ingroup heap_algorithms
408 * This operation makes the elements in [first,last) into a heap.
409 * Comparisons are made using comp.
411 template<typename _RandomAccessIterator, typename _Compare>
413 make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
416 typedef typename iterator_traits<_RandomAccessIterator>::value_type
418 typedef typename iterator_traits<_RandomAccessIterator>::difference_type
421 // concept requirements
422 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
423 _RandomAccessIterator>)
424 __glibcxx_requires_valid_range(__first, __last);
426 if (__last - __first < 2)
429 const _DistanceType __len = __last - __first;
430 _DistanceType __parent = (__len - 2) / 2;
433 _ValueType __value = _GLIBCXX_MOVE(*(__first + __parent));
434 std::__adjust_heap(__first, __parent, __len, _GLIBCXX_MOVE(__value),
443 * @brief Sort a heap.
444 * @param first Start of heap.
445 * @param last End of heap.
446 * @ingroup heap_algorithms
448 * This operation sorts the valid heap in the range [first,last).
450 template<typename _RandomAccessIterator>
452 sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
454 // concept requirements
455 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
456 _RandomAccessIterator>)
457 __glibcxx_function_requires(_LessThanComparableConcept<
458 typename iterator_traits<_RandomAccessIterator>::value_type>)
459 __glibcxx_requires_valid_range(__first, __last);
460 __glibcxx_requires_heap(__first, __last);
462 while (__last - __first > 1)
465 std::__pop_heap(__first, __last, __last);
470 * @brief Sort a heap using comparison functor.
471 * @param first Start of heap.
472 * @param last End of heap.
473 * @param comp Comparison functor to use.
474 * @ingroup heap_algorithms
476 * This operation sorts the valid heap in the range [first,last).
477 * Comparisons are made using comp.
479 template<typename _RandomAccessIterator, typename _Compare>
481 sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
484 // concept requirements
485 __glibcxx_function_requires(_Mutable_RandomAccessIteratorConcept<
486 _RandomAccessIterator>)
487 __glibcxx_requires_valid_range(__first, __last);
488 __glibcxx_requires_heap_pred(__first, __last, __comp);
490 while (__last - __first > 1)
493 std::__pop_heap(__first, __last, __last, __comp);
497 #ifdef __GXX_EXPERIMENTAL_CXX0X__
499 * @brief Search the end of a heap.
500 * @param first Start of range.
501 * @param last End of range.
502 * @return An iterator pointing to the first element not in the heap.
503 * @ingroup heap_algorithms
505 * This operation returns the last iterator i in [first, last) for which
506 * the range [first, i) is a heap.
508 template<typename _RandomAccessIterator>
509 inline _RandomAccessIterator
510 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
512 // concept requirements
513 __glibcxx_function_requires(_RandomAccessIteratorConcept<
514 _RandomAccessIterator>)
515 __glibcxx_function_requires(_LessThanComparableConcept<
516 typename iterator_traits<_RandomAccessIterator>::value_type>)
517 __glibcxx_requires_valid_range(__first, __last);
519 return __first + std::__is_heap_until(__first, std::distance(__first,
524 * @brief Search the end of a heap using comparison functor.
525 * @param first Start of range.
526 * @param last End of range.
527 * @param comp Comparison functor to use.
528 * @return An iterator pointing to the first element not in the heap.
529 * @ingroup heap_algorithms
531 * This operation returns the last iterator i in [first, last) for which
532 * the range [first, i) is a heap. Comparisons are made using comp.
534 template<typename _RandomAccessIterator, typename _Compare>
535 inline _RandomAccessIterator
536 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
539 // concept requirements
540 __glibcxx_function_requires(_RandomAccessIteratorConcept<
541 _RandomAccessIterator>)
542 __glibcxx_requires_valid_range(__first, __last);
544 return __first + std::__is_heap_until(__first, std::distance(__first,
550 * @brief Determines whether a range is a heap.
551 * @param first Start of range.
552 * @param last End of range.
553 * @return True if range is a heap, false otherwise.
554 * @ingroup heap_algorithms
556 template<typename _RandomAccessIterator>
558 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
559 { return std::is_heap_until(__first, __last) == __last; }
562 * @brief Determines whether a range is a heap using comparison functor.
563 * @param first Start of range.
564 * @param last End of range.
565 * @param comp Comparison functor to use.
566 * @return True if range is a heap, false otherwise.
567 * @ingroup heap_algorithms
569 template<typename _RandomAccessIterator, typename _Compare>
571 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
573 { return std::is_heap_until(__first, __last, __comp) == __last; }
576 _GLIBCXX_END_NAMESPACE
578 #endif /* _STL_HEAP_H */