STL Source Analysis Reading notes: The 6th chapter: algorithm Inplace_merge algorithm

1. The Inplace_merge () function combines two sorted sequences (first, middle) and [middle, last) together into a single sequence and remains in order. The Inplace_merge () function is a stable operation.

2, Inplace_merge () version of the source code, only discussed the case of a temporary buffer

Template <class bidirectionaliterator> inline void Inplace_merge (bidirectionaliterator Bidirectionaliterator Middle, Bidirectionaliterator last) {//One of the sequences is empty and does nothing if (A/= Middle | | middle = last) ret
	Urn
__inplace_merge_aux (middle, Last, Value_type (a), Distance_type (a); }//Auxiliary functions template <class Bidirectionaliterator, class T, class distance> inline void __inplace_merge_aux (bidirectio
	Naliterator, Bidirectionaliterator Middle, bidirectionaliterator last, t*, distance*) {Distance len1 = 0;
	Distance (middle, len1);
	Distance len2 = 0;
	Distance (middle, last, len2);
	will use additional memory space Temporary_buffer<bidirectionaliterator, t> buf (a);
	if (buf.begin () = = 0)//memory configuration failed __merge_without_buffer (A, middle, last, len1, len2);
else//in the case of a temporary buffer (__merge_adaptive, middle, last, Len1, Len2, Buf.begin (), Distance (buf.size)); }//auxiliary functions, in the case of a temporary buffer template <class Bidirectionaliterator, class Distance, Class pointer> void __merge_adaptive (Bidirectionaliterator, Bidirectionaliterator Middle, BidirectionalIterator Last, Distance len1, Distance len2, pointer buffer, Distance buffer_size) {if (len1 <= len2 && len1 <= bu
		Ffer_size) {//case1: Buffer sufficient to place sequence one pointer end_buffer = copy (first, middle, buffer);
	Merge (buffer, End_buffer, middle, last, a);
		else if (len2 <= buffer_size) {//case2: buffer enough to place the sequence two pointer end_buffer = copy (middle, last, buffer);
	__merge_backward (middle, buffer, end_buffer, last);
		else {//case3: buffer cannot place any sequence bidirectionaliterator first_cut = A;
		Bidirectionaliterator second_cut = middle;
		Distance len11 = 0;
		Distance len22 = 0;
			if (Len1 > Len2) {///sequence one ratio sequence two long len11 = LEN1/2;
			Advance (First_cut, len11);
			Second_cut = Lower_bound (middle, last, *first_cut);
		Distance (middle, second_cut, len22);
			else {///sequence two-ratio sequence a long len22 = LEN2/2;
			Advance (Second_cut, len22); First_cut = Upper_bound (the, middle, *second_cut);
		Distance (first_cut, len11); }//rotation operation Bidirectionaliterator new_middle = __rotate_adaptive (First_cut, Middle, second_cut, Len1-len11, Len22
		, buffer, buffer_size);
		The recursive call to the left segment __merge_adaptive (First_cut, New_middle, len11, len22, buffer, buffer_size);
	To the right end recursion calls __merge_adaptive (New_middle, Second_cut, Last, len1-len11, len2-len22, buffer, buffer_size); } template <class BidirectionalIterator1, class BidirectionalIterator2, class distance> BidirectionalIterator1 _ _rotate_adaptive (BidirectionalIterator1, BidirectionalIterator1 Middle, BidirectionalIterator1 last, Distance Len1, Distance len2, BidirectionalIterator2 buffer, Distance buffer_size) {<span style= "White-space:pre" > </
Span>bidirectionaliterator2 Buffer_end; <span style= "White-space:pre" > </span>if (Len1 > Len2 && len2 <= buffer_size) {<span style= " White-space:pre "> </span>//buffer can place sequence two <spanstyle= "White-space:pre" > </span>buffer_end = Copy (middle, last, buffer);
<span style= "White-space:pre" > </span>copy_backward (in the last);
<span style= "White-space:pre" > </span>return copy (buffer, buffer_end, a); <span style= "White-space:pre" > </span> <span style= "White-space:pre" > </span>else if (len1 <= buffer_size) {<span style= "white-space:pre" > </span>//buffer can place sequence one <span style= "White-space:pre"
> </span>buffer_end = Copy (middle, buffer);
<span style= "White-space:pre" > </span>copy (Middle, last, I);
<span style= "White-space:pre" > </span>return copy_backward (Buffer, buffer_end, last);
<span style= "White-space:pre" > </span>} <span style= "White-space:pre" > </span>else  { <span style= "White-space:pre" > </span>//buffer is insufficient, invoke rotate () function <span style= "White-space:pre" > </
Span>rotate (middle, last); &lT;span style= "White-space:pre" > </span>advance (i, len2);
<span style= "White-space:pre" > </span>return;
 <span style= "White-space:pre" > </span>}

3. Graphic description

Case 1: Buffer enough to place the sequence one

Case 2: Buffer enough to place the sequence two

Case 3: Assuming the buffer size is 3, less than the length of sequence one 4 and the length of sequence two 5, the buffer cannot place any one sequence

After the rotation operation:

Recursive call to left segment:

Right-end recursive invocation:

Sorting completed.