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.
51 /** @file bits/stl_heap.h
52 * This is an internal header file, included by other library headers.
53 * Do not attempt to use it directly. @headername{queue}
59 #include <debug/debug.h>
60 #include <bits/move.h>
62 _GLIBCXX_BEGIN_NAMESPACE(std
)
65 * @defgroup heap_algorithms Heap
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 */