Today, I learned about the analysis and routine of the merge algorithms of other Daniel, and then wrote a non-recursive merge algorithm based on the relevant information, so that I can easily review it later:
Template <class T>
Void Merge (t src [], t Dest [], int isrcstart, int isrcend, int isrcarrlength) // because SRC contains two sequential sequences, therefore, you need to input parameters to inform the start of the two sequences.
{
Int I = iSrcStart-1;
Int K = isrcstart; // DEST Index
Int J = isrcend + 1;
For (; isrcstart <= isrcend & J <= isrcarrlength; k ++)
{
If (SRC [isrcstart] <SRC [J])
{
Dest [k] = SRC [isrcstart ++];
}
Else
{
Dest [k] = SRC [J ++];
}
}
Int L = 0;
If (isrcstart <= isrcend)
{
For (; L <= isrcend-isrcstart; l ++)
{
Dest [K + L] = SRC [isrcstart + L];
}
}
If (j <= isrcarrlength)
{
For (L = 0; L <= isrcarrlength-J; l ++)
{
Dest [K + L] = SRC [J + L];
}
}
}
/*************************************** *********************************/
/* Merge the adjacent imergelength sequence in SRC into DEST */
/*************************************** *********************************/
Template <class T>
Void mergepass (t src [], t Dest [], int imergelength, int isrclength)
{
Int I = 0;
Int J = 0;
While (I <iSrcLength-2 * imergelength + 1)
{
Merge (SRC, DEST, I, imergelength + I-1, 2 * imergelength + i-1 );
I + = 2 * imergelength;
}
If (isrclength-I + 1> imergelength)
{
Merge (SRC, DEST, I, imergelength + I-1, isrclength );
}
Else
{
For (j = I; j <= isrclength; j ++)
{
Dest [J] = SRC [J];
}
}
}
// Merge-non-recursion
Template <class T>
Void mergesort (T srcarr [], int iarrlength)
{
Int I = 1;
Int J = 0;
Int K = 1;
T * TMP = new T [iarrlength + 1];
Memset (TMP, 0, sizeof (t) * (iarrlength + 1 ));
While (k <iarrlength)
{
Mergepass (srcarr, TMP, K, iarrlength );
K = 2 * K;
Mergepass (TMP, srcarr, K, iarrlength );
K = K * 2;
}
Delete [] TMP;
}
Int main (INT argc, char * argv [])
{
Int A [9] = {1, 3, 6, 7, 4, 8, 5, 2, 9 };
Double B [10] = {1.0, 10.0, 2.0, 5.0, 6.0, 4.0, 3.0, 8.0, 7.0 };
Mergesort (A, 8 );
Mergesort (B, 9 );
Return 0;
}
This is effective for merging built-in types and the custom types need to be modified.