解説クラスＣｏｐｙＣｌｅａｒ（２０）
解説クラスＣｏｐｙＣｌｅａｒ（２０）
【ソーティング小技】系の関数の解説を行います！
この講義は解説『解説クラスＣｏｐｙＣｌｅａｒ（１９）』
の続きです！
２０２５年１月２５初講（初稿）
（４－１４－１０３）関数「void SortUpdate(int sw,BYTE buf[],
int size,int d){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝BYTE *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
BYTE buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
BYTE buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え「BYTE buf[],」は、インデックス配列に依って並び替える
配列！
「BYTE buf[],」は、「BYTE型」＝「unsigned char」型と
符号無し１バイト単位データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「int d」は、アップデートするデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}（Ｄ－１）ローカル変数
){
int i; // カウンタ／index
int j; // カウンタ／index「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の
「if(d>=buf[size-1]){return;}」は、
条件「d>=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の
「if(d<=buf[size-1]){return;}」は、
条件「d<=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1];}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i]=d;」は、空いた場所をアップデートデータを
挿入します！
（４－１４－１０４）関数「void SortUpdate(int sw,short buf[],
int size,int d){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝short *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
short buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
short buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え「short buf[],」は、インデックス配列に依って並び替える
配列！
「short buf[],」は、「short型」と符号有り２バイト単位
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「int d」は、アップデートするデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}（Ｄ－１）ローカル変数
「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の
「if(d>=buf[size-1]){return;}」は、
条件「d>=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の
「if(d<=buf[size-1]){return;}」は、
条件「d<=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1];}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i]=d;」は、空いた場所をアップデートデータを
挿入します！
（４－１４－１０５）関数「void SortUpdate(int sw,int buf[],
int size,int d){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝int *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
int buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
int buf[], // バッファー
int size, // バッファーサイズ
int d // データ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え「int buf[],」は、インデックス配列に依って並び替える
配列！
「int buf[],」は、「int型」と符号有り４バイト単位
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「int d」は、アップデートするデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}（Ｄ－１）ローカル変数
){
int i; // カウンタ／index
int j; // カウンタ／index「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の「if(d>=buf[size-1]){return;}」
は、条件「d>=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の「if(d<=buf[size-1]){return;}」は、
条件「d<=buf[size-1]」と仮引数「int d」が、
「buf[size-1]」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1];}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i]=d;」は、空いた場所をアップデートデータを
挿入します！
（４－１４－１０６）関数「void SortUpdate(int sw,float buf[],
int size,double d){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝float *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
float buf[], // バッファー
int size, // バッファーサイズ
double d // データ
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = (float)d; // データをセット
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
float buf[], // バッファー
int size, // バッファーサイズ
double d // データ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え「float buf[],」は、インデックス配列に依って並び替える
配列！
「float buf[],」は、「float型」と単精度浮動小数型
４バイト単位データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「double d」は、アップデートするデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = (float)d; // データをセット
}（Ｄ－１）ローカル変数
){
int i; // カウンタ／index
int j; // カウンタ／index「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = (float)d; // データをセット
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の「if(d>=buf[size-1]){return;}」
は、条件「d>=buf[size-1]」と仮引数「double d」が、
「buf[size-1]」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の「if(d<=buf[size-1]){return;}」は、
条件「d<=buf[size-1]」と仮引数「double d」が、
「buf[size-1]」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1];}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i]=(float)d;」は、空いた場所をアップデートデータを
挿入します！
（４－１４－１０７）関数「void SortUpdate(int sw,double buf[],
int size,double d){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝double *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
double buf[], // バッファー
int size, // バッファーサイズ
double d // データ
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
double buf[], // バッファー
int size, // バッファーサイズ
double d // データ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「double buf[],」は、インデックス配列に依って並び替える
配列！「double buf[],」は、「double型」と倍精度浮動小数
８バイト単位データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「double d」は、アップデートするデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}（Ｄ－１）ローカル変数
){
int i; // カウンタ／index
int j; // カウンタ／index「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ] ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ] ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i] ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i] = d; // データをセット
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の「if(d>=buf[size-1]){return;}」
は、条件「d>=buf[size-1]」と仮引数「double d」が、
「buf[size-1]」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の「if(d<=buf[size-1]){return;}」は、
条件「d<=buf[size-1]」と仮引数「double d」が、
「buf[size-1]」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i]){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i]){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1];}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i]=d;」は、空いた場所をアップデートデータを
挿入します！
（４－１４－１０８）関数「void SortUpdate(int sw,
TypeCorr buf[],int size,
double d,int x,int y){・・・｝」
/************************************************************************/
/***** １データ更新ソート：データ＝TypeCorr *****/
/************************************************************************/
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
TypeCorr buf[], // バッファー
int size, // バッファーサイズ
double d, // データ
int x, // Ｘ座標
int y // Ｙ座標
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ].d ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ].d ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i].d = d; // データをセット
buf[i].x = x; //
buf[i].y = y; //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortUpdate()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Update」は、勿論、カタカナ語アップデートとして、
ここでは、関数「Sort○○()」で並び替えられた配列に
対して「１データ」を適応した場合に並び替える関数です！
（Ｂ）関数「void SortUpdate()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortUpdate()」の【仮引数】
void CopyClear::SortUpdate(
int sw, // 0:昇順、 1:降順
TypeCorr buf[], // バッファー
int size, // バッファーサイズ
double d, // データ
int x, // Ｘ座標
int y // Ｙ座標
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeCorr buf[],」は、インデックス配列に依って並び替える
配列！「TypeCorr buf[],」は、「TypeCorr型」と
「相関値＋座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』
の中で「（２）構造体「struct構文で定義」したデータ
構造」の更に「（２－６）相関値＋座標」で説明？！≫の
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
「double d」は、アップデートする相関値のデータ！
「int x,」は、アップデートするＸ座標のデータ！
「int y 」は、アップデートするＹ座標のデータ！
（Ｄ）関数「SortUpdate()」の【アルゴリズム】
){
int i; // カウンタ／index
int j; // カウンタ／index
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ].d ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ].d ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i].d = d; // データをセット
buf[i].x = x; //
buf[i].y = y; //
}（Ｄ－１）ローカル変数
){
int i; // カウンタ／index
int j; // カウンタ／index「int i;」は、配列のアップデートする場所を示す添字
「int j;」は、配列データの隙間を開ける為の操作用添字
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートの場合
if( d >= buf[ size - 1 ].d ){ // 範囲外（大きすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d < buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
}else{ // 降順ソートの場合
if( d <= buf[ size - 1 ].d ){ // 範囲外（小さすぎる）
return; // 終了
} //
for( i = 0; i < size; i++ ){ // バッファー内で
if( d > buf[i].d ){ // 更新位置発見時
break; // Loop終了
} //
} //
} //
for( j = size - 1; j > i; j-- ){ // 更新位置以降を
buf[j] = buf[j-1]; // 後にずらす
} //
buf[i].d = d; // データをセット
buf[i].x = x; //
buf[i].y = y; //
}「if(size<=0){return;}」は、サイズが０以下なら、何も
セズ関数終了！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の「if(d>=buf[size-1].d){return;}」
は、条件「d>=buf[size-1].d」と仮引数「double d」が、
「buf[size-1].d」≪詰り、配列の最後＝昇順なので最大値≫
より大きいと昇順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d<buf[i].d){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d<buf[i].d){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
「else{・・不成立中身・・}」は、その中身≪降順ソートの
場合の処理として≫の「if(d<=buf[size-1].d){return;}」は、
条件「d<=buf[size-1].d」と仮引数「double d」が、
「buf[size-1].d」≪詰り、配列の最後＝降順なので最小値≫
より小さいと降順ソートへのアップデート出来無いとして
関数終了！
「for(i=0;i<size;i++){if(d>buf[i].d.d){break;}}」は、
ｆｏｒループ「for(i=0;i<size;i++){
・・ループ中身・・}」で配列をサーチし中身
「if(d>buf[i].d){break;}」でアップデート可能な場所が、
見つかり「break;」でｆｏｒループを抜ける！
★備考★ここまでで理解して頂いて居ると思うが、
変数「i」にアップデートする場所を示す添字が入ります！
「for(j=size-1;j>i;j--){buf[j]=buf[j-1].d;}」は、
ｆｏｒループ「for(j=size-1;j>i;j--){・・中身・・}」
で配列の最後「j=size-1;」からアップデートする場所まで
「j>i;j--」と逆順に添え字をカウントダウンし、中身
「buf[j]=buf[j-1];」と一つ後ろに移送します！
「buf[i].d=d;buf[i].x=x;buf[i].y=y;」は、空いた場所を
アップデートデータを挿入します！
（４－１４－１０９）関数「void SortMerge(int sw,
BYTE buf1[],BYTE buf2[],
BYTE buf[],int size1,int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝BYTE *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
BYTE buf1[], // バッファー：１
BYTE buf2[], // バッファー：２
BYTE buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
BYTE buf1[], // バッファー：１
BYTE buf2[], // バッファー：２
BYTE buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「BYTE buf1[],」は、１本目のソート済データ配列
「BYTE buf2[],」は、２本目のソート済データ配列
「BYTE buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「BYTE型」、１バイト整数型です！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}「size=size1+size2;」は、結果バッファーのサイズ算出！
「if(sw==0){・・成立中身・・}」は、その成立中身≪昇順
ソートの場合の処理として≫の
「for(i=0,j=0,k=0;i<size;i++){・・
中身・・}」は、ｆｏｒループ初期値「i=0,j=0,k=0;」で
結果配列用・１本目配列・２本目配列を０に初期化、ループ
条件「i<size;」と結果配列用添え字が結果のサイズ以内に
収まる様にループし、ループ中身「if(buf1[j]<=buf2[k]){
・・条件成立中身・・}」は、内側ｉｆ条件
「buf1[j]<=buf2[k]」、詰り１本目の配列の注視点≪添え
字「j」で特定≫が、２本目の配列の注視点≪添え字「k」で
特定≫以下の値の場合、内側ｉｆ成立中身「
buf[i]=buf1[j];j++;if(j>=size1){内側ｉｆ成立中身}
return;}」と「buf[i]=buf1[j];j++;」で結果配列に
１本目の注視点を格納し、１本目配列の注視点添え字を
「j++;」と次へ移動、そして「if(j>=size1){・・内側
ループ・・}return;}」、コレは、最奥のｉｆ条件
「j>=size1」と１本目の注視点の添え字が配列の範囲内なら
最奥のｉｆ条件成立「・・内側ｆｏｒループ・・」と最奥
ｆｏｒループ「for(i++;i<size;i++,k++){
buf[i]=buf2[k];}」でループ条件「i<size」と最後まで
「buf[i]=buf2[k];」で２本目のデータ配列を「k++」と
２本目の注視点添え字を次へ進めながら結果配列にコピーし
「return;」と関数を終了！
内側ｉｆ「buf1[j]<=buf2[k]){」に対する不成立「
else{・・}」の「buf[i]=buf2[k];k++;」と結果配列に
２本目の注視点を格納し、２本目配列の注視点添え字を
「k++;」と次へ移動、そして「if(k>=size2){・・最奥成立
・・}return;」と、コレは、最奥のｉｆ条件
「k>=size2」と２本目の注視点の添え字が配列の範囲内
なら最奥のｉｆ条件成立「・・内側ｆｏｒループ・・」と
最奥ｆｏｒループ「for(i++;i<size;i++,j++){
buf[i]=buf1[j];}」でループ条件「i<size」と最後まで
「buf[i]=buf1[j];」で１本目のデータ配列を「j++」と
１本目の注視点添え字を次へ進めながら結果配列にコピーし
「return;」と関数を終了！
外側の「else{・・不成立中身・・}」は、その中身≪降順
ソートの場合の処理として≫の
「for(i=0,j=0,k=0;i<size;i++){・・
中身・・}」は、ｆｏｒループ初期値「i=0,j=0,k=0;」で
結果配列用・１本目配列・２本目配列を０に初期化、ループ
条件「i<size;」と結果配列用添え字が結果のサイズ以内に
収まる様にループし、ループ中身「if(buf1[j]>=buf2[k]){
・・条件成立中身・・}」は、内側ｉｆ条件
「buf1[j]>=buf2[k]」、詰り１本目の配列の注視点≪添え
字「j」で特定≫が、２本目の配列の注視点≪添え字「k」で
特定≫以下の値の場合、内側ｉｆ成立中身「
buf[i]=buf1[j];j++;if(j>=size1){内側ｉｆ成立中身}
return;}」と「buf[i]=buf1[j];j++;」で結果配列に
１本目の注視点を格納し、１本目配列の注視点添え字を
「j++;」と次へ移動、そして「if(j>=size1){・・内側
ループ・・}return;}」、コレは、最奥のｉｆ条件
「j>=size1」と１本目の注視点の添え字が配列の範囲内なら
最奥のｉｆ条件成立「・・内側ｆｏｒループ・・」と最奥
ｆｏｒループ「for(i++;i<size;i++,k++){
buf[i]=buf2[k];}」でループ条件「i<size」と最後まで
「buf[i]=buf2[k];」で２本目のデータ配列を「k++」と
２本目の注視点添え字を次へ進めながら結果配列にコピーし
「return;」と関数を終了！
内側ｉｆ「buf1[j]>=buf2[k]){」に対する不成立「
else{・・}」の「buf[i]=buf2[k];k++;」と結果配列に
２本目の注視点を格納し、２本目配列の注視点添え字を
「k++;」と次へ移動、そして「if(k>=size2){・・最奥成立
・・}return;」と、コレは、最奥のｉｆ条件
「k>=size2」と２本目の注視点の添え字が配列の範囲内
なら最奥のｉｆ条件成立「・・内側ｆｏｒループ・・」と
最奥ｆｏｒループ「for(i++;i<size;i++,j++){
buf[i]=buf1[j];}」でループ条件「i<size」と最後まで
「buf[i]=buf1[j];」で１本目のデータ配列を「j++」と
１本目の注視点添え字を次へ進めながら結果配列にコピーし
「return;」と関数を終了！
★備考★自然言語「日本語」でＣ言語で多重に入り組んだ
ブロック構造のアルゴリズムを解説してみました？！正直、
読者の皆様の理解の役に立ったか如何か自信有りません！
寧ろ、Ｃ言語コードの右側のコメントを参考にして読み解い
た方が簡単かもしれません！アルゴリズム自体は、明確に
ルールの決まって居るコンピュータ言語の方が判り易いと
思います！
（４－１４－１１０）関数「void SortMerge(int sw,
short buf1[],short buf2[],
short buf[],int size1,int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝short *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
short buf1[], // バッファー：１
short buf2[], // バッファー：２
short buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
short buf1[], // バッファー：１
short buf2[], // バッファー：２
short buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「short buf1[],」は、１本目のソート済データ配列
「short buf2[],」は、２本目のソート済データ配列
「short buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「short型」、２バイト整数型です！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}「size=size1+size2;」は、結果バッファーのサイズ算出！
★備考★ここまでの記述は、（４－１４－１０９のＤ）と
同じです！更に言えば、この（４－１４－１０９のＤ）の
アルゴリズムコードは、（４－１４－１０９のＤ）と全く同
じです！今回は、（４－１４－１０１０９のＤ）の日本語での
説明が私的に納得出来無いので別の説明アプローチをさせて
貰います！
（１）全体
if( sw == 0 ){
・・昇順ソート処理・・
}else{
・・降順ソート処理・・
}
（２）昇順ソート処理
「for(i=0,j=0,k=0;i<size;i++){・外側ループ中身・}」は、
ｆｏｒループ構文「for(i=0,j=0,k=0;i<size;i++)」で
初期化「i=0,j=0,k=0;」と結果と元の二本の配列添え字を
０クリアし、ループ条件「i<size;」と結果配列への添え字
をループカウンタとしてサイズ目一杯、そしてループ本体後
処理「i++」と結果配列添え字を進める
（２－１）外側ループ中身の処理
ｉｆ分岐構文「if(buf1[j]<=buf2[k]){・・成立・・}else{
・・不成立・・」と成り、条件「buf1[j]<=buf2[k]」と
１本目配列≪これから配列１と呼称≫の注視点が２本目配列
≪これから配列２と呼称≫の注視点以下の場合を成立
（２－１－１）成立の処理
「buf[i]=buf1[j];j++;」で結果配列に配列１の注視点を
コピーし、配列１添え字を進める！
最奥のｉｆ分岐構文「if(j>=size1){・・最奥成立・・}」
条件「j>=size1」で配列１添え字が最後に到達した場合
（２－１－１－１）最奥成立の処理
「for(i++;i<size;i++,k++){buf[i]=buf2[k];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,k++」と結果配列添え字と配列２添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf2[k];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（２－１－２）不成立の処理
「buf[i]=buf2[k];k++;」で結果配列に配列２の注視点を
コピーし、配列２添え字を進める！
最奥のｉｆ分岐構文「if(k>=size2){){・・最奥成立・・}」
条件「k>=size2」で配列２添え字が最後に到達した場合
（２－１－２－１）最奥成立の処理
「for(i++;i<size;i++,j++){buf[i]=buf1[j];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,j++」と結果配列添え字と配列１添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf1[j];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（３）降順ソート処理
「for(i=0,j=0,k=0;i<size;i++){・外側ループ中身・}」は、
ｆｏｒループ構文「for(i=0,j=0,k=0;i<size;i++)」で
初期化「i=0,j=0,k=0;」と結果と元の二本の配列添え字を
０クリアし、ループ条件「i<size;」と結果配列への添え字
をループカウンタとしてサイズ目一杯、そしてループ本体後
処理「i++」と結果配列添え字を進める
（３－１）外側ループ中身の処理
ｉｆ分岐構文「if(buf1[j]>=buf2[k]){・・成立・・}else{
・・不成立・・」と成り、条件「buf1[j]>=buf2[k]」と
配列１の注視点が配列２の注視点以下の場合を成立
（３－１－１）成立の処理
「buf[i]=buf1[j];j++;」で結果配列に配列１の注視点を
コピーし、配列１添え字を進める！
最奥のｉｆ分岐構文「if(j>=size1){・・最奥成立・・}」
条件「j>=size1」で配列１添え字が最後に到達した場合
（３－１－１－１）最奥成立の処理
「for(i++;i<size;i++,k++){buf[i]=buf2[k];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,k++」と結果配列添え字と配列２添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf2[k];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（３－１－２）不成立の処理
「buf[i]=buf2[k];k++;」で結果配列に配列２の注視点を
コピーし、配列２添え字を進める！
最奥のｉｆ分岐構文「if(k>=size2){){・・最奥成立・・}」
条件「k>=size2」で配列２添え字が最後に到達した場合
（３－１－２－１）最奥成立の処理
「for(i++;i<size;i++,j++){buf[i]=buf1[j];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,j++」と結果配列添え字と配列１添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf1[j];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（４－１４－１１１）関数「void SortMerge(int sw,int buf1[],
int buf2[],int buf[],int size1,
int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝int *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
int buf1[], // バッファー：１
int buf2[], // バッファー：２
int buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
int buf1[], // バッファー：１
int buf2[], // バッファー：２
int buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「int buf1[],」は、１本目のソート済データ配列
「int buf2[],」は、２本目のソート済データ配列
「int buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「int型」、４バイト整数型です！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}「size=size1+size2;」は、結果バッファーのサイズ算出！
★備考★ここまでの記述は、（４－１４－１０９のＤ）と
同じです！更に言えば、この（４－１４－１１１のＤ）の
アルゴリズムコードは、（４－１４－１０９のＤ）と全く同
じです！今回は、（４－１４－１０１０９のＤの日本語での
説明が私的に納得出来無いので別の説明アプローチをさせて
貰います！
（１）全体
if( sw == 0 ){
・・昇順ソート処理・・
}else{
・・降順ソート処理・・
}
（２）昇順ソート処理
「for(i=0,j=0,k=0;i<size;i++){・外側ループ中身・}」は、
ｆｏｒループ構文「for(i=0,j=0,k=0;i<size;i++)」で
初期化「i=0,j=0,k=0;」と結果と元の二本の配列添え字を
０クリアし、ループ条件「i<size;」と結果配列への添え字
をループカウンタとしてサイズ目一杯、そしてループ本体後
処理「i++」と結果配列添え字を進める
（２－１）外側ループ中身の処理
ｉｆ分岐構文「if(buf1[j]<=buf2[k]){・・成立・・}else{
・・不成立・・」と成り、条件「buf1[j]<=buf2[k]」と
１本目配列≪これから配列１と呼称≫の注視点が２本目配列
≪これから配列２と呼称≫の注視点以下の場合を成立
（２－１－１）成立の処理
「buf[i]=buf1[j];j++;」で結果配列に配列１の注視点を
コピーし、配列１添え字を進める！
最奥のｉｆ分岐構文「if(j>=size1){・・最奥成立・・}」
条件「j>=size1」で配列１添え字が最後に到達した場合
（２－１－１－１）最奥成立の処理
「for(i++;i<size;i++,k++){buf[i]=buf2[k];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,k++」と結果配列添え字と配列２添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf2[k];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（２－１－２）不成立の処理
「buf[i]=buf2[k];k++;」で結果配列に配列２の注視点を
コピーし、配列２添え字を進める！
最奥のｉｆ分岐構文「if(k>=size2){){・・最奥成立・・}」
条件「k>=size2」で配列２添え字が最後に到達した場合
（２－１－２－１）最奥成立の処理
「for(i++;i<size;i++,j++){buf[i]=buf1[j];}return;」と
最奥の内側ループでｆｏｒループ構文「for(i++;i<size;
i++,k++)」で初期化「i++;」と結果配列添え字を進め、
ループ条件「i<size」と結果配列への添え字をループカウ
ンタとしてサイズ目一杯、そしてループ本体後処理「
i++,j++」と結果配列添え字と配列１添え字を進め、
最奥の内側ループ処理本体で「buf[i]=buf1[j];」と
結果配列に配列２の注視点をコピーし、配列２添え字を
進め（★備考★これはループ本体後処理）る！そして
「return;」で関数終了！
（３）降順ソート処理
★備考★今回は、（４－１４－１１０のＤ）の説明記載が
長過ぎてウンザリしたと考えて要約します！
ここの降順ソート処理が（２）昇順ソート処理との相違点
は、昇順ソートでの≪ｉｆ分岐構文「if(buf1[j]<=buf2[k]
){・・成立・・}else{・・不成立・・」と成り、条件「
buf1[j]<=buf2[k]」の条件≫が、降順ソートの場合は、
≪ｉｆ分岐構文「if(buf1[j]>=buf2[k]){・・成立・・}
else{・・不成立・・」と成り、
条件「buf1[j]>=buf2[k]」の条件≫に成る、≪「<=」が、
「<=」に変更≫⇒勿論、昇順≪小から大へ≫が降順≪大から
小へ≫の違いとは理解して頂けると思います！
（４－１４－１１２）関数「void SortMerge(int sw,float buf1[],
float buf2[],float buf[],int size1,
int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝float *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
float buf1[], // バッファー：１
float buf2[], // バッファー：２
float buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
float buf1[], // バッファー：１
float buf2[], // バッファー：２
float buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「float buf1[],」は、１本目のソート済データ配列
「float buf2[],」は、２本目のソート済データ配列
「float buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「float型」、単精度浮動小数型で
す！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}★備考★ここまでの記述は、（４－１４－１０９のＤ）と
同じです！更に言えば、この（４－１４－１１１のＤ）の
アルゴリズムコードは、（４－１４－１０９のＤ）と全く同
じです！今回は、（４－１４－１０１０９のＤの日本語での
説明が私的に納得出来無いので別の説明アプローチをさせて
貰います！
★備考★アルゴリズムコードは、（４－１４－１０９のＤ）
と全く同じですので（４－１４－１１１のＤ）の説明を参考
にして下さい！ここでは、説明は省きます！
（４－１４－１１３）関数「void SortMerge(int sw,
double buf1[],
double buf2[],double buf[],
int size1,int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝double *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
double buf1[], // バッファー：１
double buf2[], // バッファー：２
double buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
double buf1[], // バッファー：１
double buf2[], // バッファー：２
double buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「double buf1[],」は、１本目のソート済データ配列
「double buf2[],」は、２本目のソート済データ配列
「double buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「double型」、倍精度浮動小数型で
す！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] <= buf2[k] ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j] >= buf2[k] ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}★備考★ここまでの記述は、（４－１４－１０９のＤ）と
同じです！更に言えば、この（４－１４－１１１のＤ）の
アルゴリズムコードは、（４－１４－１０９のＤ）と全く同
じです！今回は、（４－１４－１０１０９のＤの日本語での
説明が私的に納得出来無いので別の説明アプローチをさせて
貰います！
★備考★アルゴリズムコードは、（４－１４－１０９のＤ）
と全く同じですので（４－１４－１１１のＤ）の説明を参考
にして下さい！ここでは、説明は省きます！
（４－１４－１１４）関数「void SortMerge(int sw,
TypeCorr buf1[],
TypeCorr buf2[],TypeCorr buf[],
int size1,int size2) {・・・｝」
/************************************************************************/
/***** 併合ソート：データ＝TypeCorr *****/
/***** 「buf1」、「buf2」共「sw」で指定したソート済みが条件 *****/
/************************************************************************/
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
TypeCorr buf1[], // バッファー：１
TypeCorr buf2[], // バッファー：２
TypeCorr buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d <= buf2[k].d ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d >= buf2[k].d ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortMerge()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Merge」は、英語「merge」、「併合する、溶け合わせる」
です！ソーティングアルゴリズムとしては、マージソート≪
元々、古いコンピュータシステム（補助記憶装置が磁気テー
プ）で磁気テープのデータをマージする事で長大なソート済
みの２本の磁気テープから両方のデータを併合し一本のソー
ト済データを作成する事で考えられた、２本のソート済デー
タから１本の連続するソートデータを作成するソート方法≫
です！
（Ｂ）関数「void SortMerge()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortMerge()」の【仮引数】
void CopyClear::SortMerge(
int sw, // 0:昇順、 1:降順
TypeCorr buf1[], // バッファー：１
TypeCorr buf2[], // バッファー：２
TypeCorr buf[], // バッファー：格納先
int size1, // バッファーサイズ：１
int size2 // バッファーサイズ：２
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeCorr buf1[],」は、１本目のソート済データ配列
「TypeCorr buf2[],」は、２本目のソート済データ配列
「TypeCorr buf[],」は、併合処理した結果のデータ配列
この関数は、配列が全て「TypeCorr型」です！
「TypeCorr型」と「相関値＋座標組型」≪解説『
解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct
構文で定義」したデータ構造」の更に「（２－６）相関値＋
座標」で説明？！≫のデータのソート対象一次元配列！
「int size1,」は、１本目のソート対象一次元配列の
データ数！
「int size2」は、２本目のソート対象一次元配列のデータ
数！
（Ｄ）関数「SortMerge()」の【アルゴリズム】
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d <= buf2[k].d ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d >= buf2[k].d ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}（Ｄ－１）ローカル変数
){
int size; // バッファーサイズ
int i; // カウンタ：格納
int j; // カウンタ：１
int k; // カウンタ：２「int size;」は、結果バッファーのサイズ
「int i;」は、結果配列の添え字＆ループ用カウンタ
「int j;」は、１本目の配列の添え字
「int k;」は、２本目の配列の添え字
（Ｄ－２）アルゴリズムコード
size = size1 + size2; // 総サイズ算出
if( sw == 0 ){ // 昇順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d <= buf2[k].d ){ // 「１」側が小なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が大なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
}else{ // 降順ソートの場合
for( i = 0, j = 0, k = 0; i < size; i++ ){ // 全体で
if( buf1[j].d >= buf2[k].d ){ // 「１」側が大なら
buf[i] = buf1[j]; // 「１」側を格納し
j++; // 「１」側カウントUP
if( j >= size1 ){ // 「１」側終了したら
for( i++; i < size; i++, k++ ){ // 「２」側を
buf[i] = buf2[k]; // 最後まで格納し
} //
return; // 終了
} //
}else{ // 「１」側が小なら
buf[i] = buf2[k]; // 「２」側を格納し
k++; // 「２」側カウントUP
if( k >= size2 ){ // 「２」側終了したら
for( i++; i < size; i++, j++ ){ // 「１」側を
buf[i] = buf1[j]; // 最後まで格納し
} //
return; // 終了
} //
} //
} //
} //
}★備考★ここまでの記述は、（４－１４－１０９のＤ）と
同じです！更に言えば、この（４－１４－１１１のＤ）の
アルゴリズムコードは、（４－１４－１０９のＤ）と全く同
じです！今回は、（４－１４－１０１０９のＤの日本語での
説明が私的に納得出来無いので別の説明アプローチをさせて
貰います！
★備考★アルゴリズムコードは、（４－１４－１０９のＤ）
と全く同じですので（４－１４－１１１のＤ）の説明を参考
にして下さい！ここでは、説明は省きます！
ここでは、差分だけ説明します！
差分は、（４－１４－１０８）から（４－１４－１１２）
まででは、「「if(buf1[j]<=buf2[k])」等の
配列１と配列２のデータの大小比較している所が、
ここでは、「「if(buf1[j].d<=buf2[k].d)」等と、
「TypeCorr型」の相関値を比較するメンバー変数「.d」に
対して比較している事が違う所です！
本日（１月２５）の講義はココまでとします！
流石に新しくと言うか大量の解説なので受講者の皆様が、
消化出来る為にココまでとします！
次から、【マルチ・ソーティング】系の関数の解説に成るので
新しく新規解説『解説クラスＣｏｐｙＣｌｅａｒ（２１）』
として近々、始めますので宜しく、御贔屓の程、お願いしま
す！