解説クラスＣｏｐｙＣｌｅａｒ（１８）
解説クラスＣｏｐｙＣｌｅａｒ（１８）
２０２５年１月２３初講（初稿）
この講義は解説『解説クラスＣｏｐｙＣｌｅａｒ（１７）』
の続きです！
ガラッと内容が、変わって【ソーティング】系の関数の解説
に成ります！記載は、
解説『解説クラスＣｏｐｙＣｌｅａｒ（１）』で
「（２）クラス定義」
でのＣ＋＋言語クラス定義の「
class CopyClear : public Support // クラス定義
{・・・・・};」
での「public:」とパブリック属性の関数から説明して居る
為でヘッダファイル「CopyClear.h」の順番に従って説明し
て居るからで、今回は、【ソーティング】系の関数の番に
成ります！
（４－１４－４５）関数「int Sort(int sw,TypeArray* pa,int n){・・・｝」
/************************************************************************/
/***** ＳＯＲＴコマンド ：実行部 *****/
/***** ＳＯＲＴ，ｓｗ｛，array｝ *****/
/************************************************************************/
int CopyClear::Sort(
int sw, // 0:昇順、1:降順
TypeArray *pa, // 配列1～100の情報
int n // 配列の個数 1..100
){
int l; // 配列のサイズ
l = CheckArraySort( pa, n ); // 配列の検査
if( l < 0 ){ // Sizeが負ならErrSt
return( l ); // atusと見なしてそ
} // の値を返す
if( n == 1 ){ // １個の配列Sort時
sort_single( sw, pa, l ); // 左記でソート
}else{ // 複数の配列Sort時
if( l < 32767 ){ // Sizeが15bit以内で
return( SortMult( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
}else{ // 上記を超えたら
return( SortMultLarge( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
} //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「int Sort()」の【返値】
検査関数「CheckArraySort()」で負の値に成れば、その値を
辺値とし返す！処理終了したら、正常終了「END_STI」を
返す！と記載しましたが、「END_STI＝0」なので実は、
正常終了と言う依りも、処理した個数が０を意味し、
サブルーチン関数「sort_single()」・
関数「SortMultLarge()」での辺値≪実は、処理した個数≫
を返します！解説『エラーコード等各種単純定義』で
「END_STI」等の定義は解説しています！
（Ｃ）関数「Sort()」の【仮引数】
int CopyClear::Sort(
int sw, // 0:昇順、1:降順
TypeArray *pa, // 配列1～100の情報
int n // 配列の個数 1..100
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeArray* pa,」は、画像で無く一次元配列へのポイン
タとして扱います！
「int n」は、配列の個数です！★備考★「*pa,」とポイ
ンタに成って居る配列が複数存在する事も可能です！
★注意★何故、この様な関数が存在するかと言うと、
複数の配列を処理する場合と、もう一つ
ＡＤＳ社画像処理装置に簡易コマンド言語「ＰＩＰＬ」で
使用する為に開発当時は、構造体「TypeArray」でコマンド
の型で使用出来る様に扱う仕掛けで必要なだけでＣ言語で
ライブラリ関数を使用する人には知らなくても良い話ですが
私としては、画像処理言語「ＰＩＰＬ」をリニューアル作成
する心算ですので残して置いたのです！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
int l; // 配列のサイズ
l = CheckArraySort( pa, n ); // 配列の検査
if( l < 0 ){ // Sizeが負ならErrSt
return( l ); // atusと見なしてそ
} // の値を返す
if( n == 1 ){ // １個の配列Sort時
sort_single( sw, pa, l ); // 左記でソート
}else{ // 複数の配列Sort時
if( l < 32767 ){ // Sizeが15bit以内で
return( SortMult( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
}else{ // 上記を超えたら
return( SortMultLarge( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
} //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int l; // 配列のサイズ「int l;」は、ソーティング時の有効長★注意★配列が
２個以上あれば、有効長は、各配列の最小値！
（Ｄ－２）アルゴリズムコード
l = CheckArraySort( pa, n ); // 配列の検査
if( l < 0 ){ // Sizeが負ならErrSt
return( l ); // atusと見なしてそ
} // の値を返す
if( n == 1 ){ // １個の配列Sort時
sort_single( sw, pa, l ); // 左記でソート
}else{ // 複数の配列Sort時
if( l < 32767 ){ // Sizeが15bit以内で
return( SortMult( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
}else{ // 上記を超えたら
return( SortMultLarge( // 左記でソート
sw, pa, pa + 1, n - 1, 0, l ) ); //
} //
} //
return( END_STI ); // 正常終了
}「l=CheckArraySort(pa,n);」は、
仮引数「TypeArray* pa,」と仮引数「int n」で引数の
検査関数「CheckArraySort()」で検査し配列サイズを算出！
★注意★複数の配列が有る場合の有効な配列サイズ（全て
の最小値）を算出！
「if(l<0){return(l);}」は、上記の検査でエラー発生時は
「return(l);」とソノ値を辺値とし返し関数終了！
「if(n==1){sort_single(sw,pa,l);}」は、配列の個数が、
「n==1」詰り、１個だけの場合、サブルーチン関数
「sort_single(sw,pa,l);」で処理します！
「else{・・条件非成立時中身・・}」は、
「if(l<32767){
return(SortMult(sw,pa,pa+1,n-1,0,l));}」と、先ず、
配列のサイズが「l<32767」と「short型」の正の値サイズ
内に収まる場合で「return(SortMult(sw,pa,pa+1,n-1,0,l
));」とサブルーチン関数「SortMult()」で処理し、その
関数辺値の値を関数の辺値として関数終了！そして
「else{・・内側の条件非成立時中身・・」と正の値サイズ
が「32767」を越えた場合≪「short型」で収まらない場合
≫に中身「return(SortMultLarge(sw,pa,pa+1,n-1,0,l
));}」とサブルーチン関数「SortMultLarge()」で
処理し、その関数辺値の値を関数の辺値として関数終了！
★注意★複数の配列の場合、最初の配列をキー配列とし、
その中でソーティングした順番で引き続く、配列が関連して
並び替えます！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
★備考★このアルゴリズムの中で≪配列のサイズが、
「l<32767」と「short型」に収まる場合と越える場合で
サブルーチン関数「SortMult()」とサブルーチン関数「
SortMultLarge()」に≫分けて居るを説明すると何方の
関数も内部でソーティングに使用するインデックス配列を
使用する事です！解説『高速大容量の代表的処理が、画像処
理』で説明した様に内部で使用するメモリーを少なくした
方が依り高速に動作する事は、理解して下さい！だから、
少量「l<32767」のデータサイズには特化した関数を使用し
ました！特に長大なデータをソーティングする必要が無い
場合の方が、アプリケーションでは多い筈です！
（４－１４－４６）関数「void Sort(int sw,BYTE buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝８bits *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
BYTE buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_byte_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_byte_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
BYTE buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「BYTE buf[],」は、「BYTE型」＝「unsigned char」型と
符号無し１バイト単位データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_byte_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_byte_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_byte_0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_byte_0(buf,&buf[size-1]);」とサブルーチン
関数「sort_byte_0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_byte_1(buf,&buf[size-1]);」とサブルーチン
関数「sort_byte_1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sort_byte_0()」・「sort_byte_1()」の説明は、恐らく、
この解説文章で無く「private:」属性の関数の解説で記載し
ますので後回しに成ります！★注意★アルゴリズム的には、
ソートアルゴリズムの定番で有る「クイック・ソート」を
使用しています！
（４－１４－４７）関数「void Sort(int sw,short buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝１６bits *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
short buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_short_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_short_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
short buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「short buf[],」は、「short型」と符号有り２バイト単位
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_short_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_short_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_short_0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_short_0(buf,&buf[size-1]);」とサブルーチン
関数「sort_short_0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_short_1(buf,&buf[size-1]);」とサブルーチン
関数「sort_short_1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sort_short_0()」・「sort_short_1()」の説明は、恐らく、
この解説文章で無く「private:」属性の関数の解説で記載し
ますので後回しに成ります！★注意★アルゴリズム的には、
ソートアルゴリズムの定番で有る「クイック・ソート」を
使用しています！
（４－１４－４８）関数「void Sort(int sw,long buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝３２bits *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
long buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_long_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_long_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
long buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「long buf[],」は、「long型」と符号有り４バイト単位
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_long_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_long_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_long _0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_long _0(buf,&buf[size-1]);」とサブルーチン
関数「sort_long _0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_long _1(buf,&buf[size-1]);」とサブルーチン
関数「sort_long _1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sort_long _0()」・「sort_long _1()」の説明は、恐らく、
この解説文章で無く「private:」属性の関数の解説で記載し
ますので後回しに成ります！★注意★アルゴリズム的には、
ソートアルゴリズムの定番で有る「クイック・ソート」を
使用しています！
（４－１４－４９）関数「void Sort(int sw,int buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝３２bits *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
int buf[], // バッファー
int size // バッファーサイズ
){
Sort( sw, (long*)buf, size ); // long型で実行
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
int buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「int buf[],」は、「int型」と符号有り４バイト単位
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
Sort( sw, (long*)buf, size ); // long型で実行
}「Sort(sw,(long *)buf,size);」と仮引数「int buf[],」を
型変換しサブルーチン関数「Sort(sw,(long *)buf,size);」
で処理！
（４－１４－５０）関数「void Sort(int sw,float buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝単精度 *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
float buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_float_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_float_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
float buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「float buf[],」は、「float型」と単精度浮動小数点型の
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_float_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_float_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_float_0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_float_0(buf,&buf[size-1]);」とサブルーチン
関数「sort_float_0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_float_1(buf,&buf[size-1]);」とサブルーチン
関数「sort_float_1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン
関数「sort_float_0()」・「sort_float_1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５１）関数「void Sort(int sw,double buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝倍精度 *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
double buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_double_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_double_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
double buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「double buf[],」は、「double型」と倍精度浮動小数点型の
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_double_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_double_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_double_0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_double_0(buf,&buf[size-1]);」と
サブルーチン関数「sort_double_0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_double_1(buf,&buf[size-1]);」と
サブルーチン関数「sort_double_1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sort_double_0()」・「sort_double_1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５２）関数「void Sort(int sw,__int 64buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝64Bit整数 *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
__int64 buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_int64_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_int64_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
__int64 buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「__int 64 buf[],」は、「__int 64型」と８バイト整数型の
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 終了
} //
if( sw == 0 ){ // 昇順ソートなら
sort_int64_0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sort_int64_1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sort_int 64_0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sort_int 64_0(buf,&buf[size-1]);」と
サブルーチン関数「sort_int 64_0()」で処理！
条件不成立＝降順ソートなら、
中身「sort_int 64_1(buf,&buf[size-1]);」と
サブルーチン関数「sort_int 64_1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sort_int 64_0()」・「sort_int 64_1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５３）関数「void Sort(int sw,TypeCorr buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeCorr *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
TypeCorr buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortTypeCorr0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortTypeCorr1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
TypeCorr buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeCorr buf[],」は、「TypeCorr型」と
「相関値＋座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』
の中で「（２）構造体「struct構文で定義」したデータ
構造」の更に「（２－６）相関値＋座標」で説明？！≫の
データのソート対象一次元配列！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortTypeCorr0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortTypeCorr1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortTypeCorr0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortTypeCorr0(buf,&buf[size-1]);」と
サブルーチン関数「sortTypeCorr0()」で処理！
条件不成立＝降順ソートなら、
中身「sortTypeCorr1(buf,&buf[size-1]);」と
サブルーチン関数「sortTypeCorr1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortTypeCorr0()」・「sortTypeCorr1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５４）関数「void Sort(int sw,TypeCorrIX buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeCorrIX *****/
/************************************************************************/
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
TypeCorrIX buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortTypeCorrIX0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortTypeCorrIX1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「Sort()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
（Ｂ）関数「void Sort()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Sort()」の【仮引数】
void CopyClear::Sort(
int sw, // 0:昇順、 1:降順
TypeCorrIX buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeCorrIX buf[],」は、「TypeCorrIX型」と
「相関値＋座標組型＋汎用Index」≪
解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－６）相関値＋座標」で説明？！≫のデータの
ソート対象一次元配列！
「TypeCorrIX」は、付帯する情報とリンクする事が、
構造体内に入って居る事が、「TypeCorr型」と違いです！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「Sort()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortTypeCorrIX0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortTypeCorrIX1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortTypeCorrIX0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortTypeCorrIX0(buf,&buf[size-1]);」と
サブルーチン関数「sortTypeCorrIX0()」で処理！
条件不成立＝降順ソートなら、
中身「sortTypeCorrIX1(buf,&buf[size-1]);」と
サブルーチン関数「sortTypeCorrIX1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortTypeCorrIX0()」・「sortTypeCorrIX1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５５）関数「void SortX(int sw,TypeXY buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYでＸ座標 *****/
/************************************************************************/
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXY buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXY0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXY1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortX()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「X」は、「Ｘ座標」を意味します！この関数は、
仮引数「TypeXY buf[],」の型「TypeXY」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＸ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortX()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortX()」の【仮引数】
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXY buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXY buf[],」は、「TypeXY 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortX()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXY0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXY1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortXTypeXY 0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortXTypeXY 0(buf,&buf[size-1]);」と
サブルーチン関数「sortXTypeXY 0()」で処理！
条件不成立＝降順ソートなら、
中身「sortXTypeXY 1(buf,&buf[size-1]);」と
サブルーチン関数「sortXTypeXY 1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortXTypeXY 0()」・「sortXTypeXY 1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５６）関数「void SortY(int sw,TypeXY buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYでＹ座標 *****/
/************************************************************************/
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXY buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXY0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXY1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortY()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Y」は、「Ｙ座標」を意味します！この関数は、
仮引数「TypeXY buf[],」の型「TypeXY」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＹ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortY()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortY()」の【仮引数】
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXY buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXY buf[],」は、「TypeXY 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortY()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXY0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXY1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortYTypeXY 0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortYTypeXY0(buf,&buf[size-1]);」と
サブルーチン関数「sortYTypeXY0()」で処理！
条件不成立＝降順ソートなら、
中身「sortYTypeXY1(buf,&buf[size-1]);」と
サブルーチン関数「sortYTypeXY1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortYTypeXY 0()」・「sortYTypeXY 1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５７）関数「void SortX(int sw,TypeXYF buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYFでＸ座標 *****/
/************************************************************************/
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYF buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYF0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYF1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortX()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「X」は、「Ｘ座標」を意味します！この関数は、
仮引数「TypeXYF buf[],」の型「TypeXYF」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＸ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortX()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortX()」の【仮引数】
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYF buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYF buf[],」は、「TypeXYF 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortX()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYF0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYF1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortXTypeXYF0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortXTypeXYF0(buf,&buf[size-1]);」と
サブルーチン関数「sortXTypeXYF0()」で処理！
条件不成立＝降順ソートなら、
中身「sortXTypeXYF1(buf,&buf[size-1]);」と
サブルーチン関数「sortXTypeXYF1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortXTypeXYF0()」・「sortXTypeXYF1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５８）関数「void SortY(int sw,TypeXYF buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYFでＹ座標 *****/
/************************************************************************/
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYF buf[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYF0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYF1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortY()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Y」は、「Ｙ座標」を意味します！この関数は、
仮引数「TypeXYF buf[],」の型「TypeXYF」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＹ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortY()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortY()」の【仮引数】
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYF buf[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYF buf[],」は、「TypeXYF 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortY()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYF0( buf, &buf[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYF1( buf, &buf[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortYTypeXYF0(buf,&buf[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortYTypeXYF0(buf,&buf[size-1]);」と
サブルーチン関数「sortYTypeXYF0()」で処理！
条件不成立＝降順ソートなら、
中身「sortYTypeXYF1(buf,&buf[size-1]);」と
サブルーチン関数「sortYTypeXYF1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortYTypeXYF0()」・「sortYTypeXYF1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－５９）関数「void SortX(int sw,TypeXYD buf[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYDでＸ座標 *****/
/************************************************************************/
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYD bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYD0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYD1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortX()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「X」は、「Ｘ座標」を意味します！この関数は、
仮引数「TypeXYD buf[],」の型「TypeXYD」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＸ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortX()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortX()」の【仮引数】
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYD bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYD bufD[],」は、「TypeXYD 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortX()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYD0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYD1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortXTypeXYD0(buf,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortXTypeXYD0(buf,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYD0()」で処理！
条件不成立＝降順ソートなら、
中身「sortXTypeXYD1(buf,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYD1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortXTypeXYD0()」・「sortXTypeXYD1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６０）関数「void SortY(int sw,TypeXYD bufD[],
int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYDでＹ座標 *****/
/************************************************************************/
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYD bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYD0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYD1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortY()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Y」は、「Ｙ座標」を意味します！この関数は、
仮引数「TypeXYD bufD[],」の型「TypeXYD」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＹ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortY()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortY()」の【仮引数】
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYD bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYD bufD[],」は、「TypeXYD 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortY()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYD0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYD1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortYTypeXYD0(buf,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortYTypeXYD0(buf,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYD0()」で処理！
条件不成立＝降順ソートなら、
中身「sortYTypeXYD1(buf,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYD1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortYTypeXYD0()」・「sortYTypeXYD1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６１）関数「void SortX(int sw,TypeXYHV bufD[],
int size){・・・｝」
/****************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYHVでＸ座標 *****/
/****************************************************************************/
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYHV bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYHV0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYHV1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortX()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「X」は、「Ｘ座標」を意味します！この関数は、
仮引数「TypeXYHV bufD[],」の型「TypeXYHV」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫の
データのソート対象一次元配列！のＸ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortX()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortX()」の【仮引数】
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYHV bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYHV bufD[],」は、「TypeXYHV 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortX()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYHV0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYHV1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortXTypeXYHV0(bufD,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortXTypeXYHV0(bufD,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYHV0()」で処理！
条件不成立＝降順ソートなら、
中身「sortXTypeXYHV1(bufD,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYHV1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortXTypeXYHV0()」・「sortXTypeXYHV1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６２）関数「void SortY(int sw,TypeXYHV bufD[],
int size){・・・｝」
/****************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYHVでＹ座標 *****/
/****************************************************************************/
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYHV bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYHV0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYHV1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortY()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Y」は、「Ｙ座標」を意味します！この関数は、
仮引数「TypeXYHV bufD[],」の型「TypeXYHV」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
データのソート対象一次元配列！のＹ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortY()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortY()」の【仮引数】
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYHV bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYHV bufD[],」は、「TypeXYHV 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortY()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYHV0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYHV1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortYTypeXYHV0(bufD,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortYTypeXYHV0(bufD,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYHV0()」で処理！
条件不成立＝降順ソートなら、
中身「sortYTypeXYHV1(bufD,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYHV1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortYTypeXYHV0()」・「sortYTypeXYHV1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６３）関数「void SortX(int sw,TypeXYHVIX bufD[],int size){・・・｝」
/****************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYHVIXでＸ座標 *****/
/****************************************************************************/
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYHVIX bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYHVIX0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYHVIX1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortX()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「X」は、「Ｘ座標」を意味します！この関数は、
仮引数「TypeXYHVIX bufD[],」の型「TypeXYHVIX」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
データのソート対象一次元配列！のＸ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortX()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortX()」の【仮引数】
void CopyClear::SortX(
int sw, // 0:昇順、 1:降順
TypeXYHVIX bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYHVIX bufD[],」は、「TypeXYHVIX 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortX()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortXTypeXYHVIX0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortXTypeXYHVIX1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortXTypeXYHVIX0(bufD,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortXTypeXYHVIX0(bufD,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYHVIX0()」で処理！
条件不成立＝降順ソートなら、
中身「sortXTypeXYHVIX1(bufD,&bufD[size-1]);」と
サブルーチン関数「sortXTypeXYHVIX1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortXTypeXYHVIX0()」・「sortXTypeXYHVIX1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６４）関数「void SortY(int sw,TypeXYHVIX bufD[],int size){・・・｝」
/****************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeXYHVIXでＹ座標 *****/
/****************************************************************************/
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYHVIX bufD[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYHVIX0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYHVIX1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortY()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Y」は、「Ｙ座標」を意味します！この関数は、
仮引数「TypeXYHVIX bufD[],」の型「TypeXYHVIX」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
データのソート対象一次元配列！のＹ座標成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortY()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortY()」の【仮引数】
void CopyClear::SortY(
int sw, // 0:昇順、 1:降順
TypeXYHVIX bufD[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeXYHVIX bufD[],」は、「TypeXYHVIX 型」と
「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で
「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortY()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortYTypeXYHVIX0( bufD, &bufD[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortYTypeXYHVIX1( bufD, &bufD[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortYTypeXYHVIX0(bufD,&bufD[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortYTypeXYHVIX0(bufD,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYHVIX0()」で処理！
条件不成立＝降順ソートなら、
中身「sortYTypeXYHVIX1(bufD,&bufD[size-1]);」と
サブルーチン関数「sortYTypeXYHVIX1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortYTypeXYHVIX0()」・「sortYTypeXYHVIX1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
本日（１月２３）の講義はココまでとします！
流石に新しくと言うか「ソート」の話に遷ったの
で受講者の皆様が消化出来る為にココまでとします！
次から、【ソーティング応用】系の関数の解説に成るので
新しく新規解説『解説クラスＣｏｐｙＣｌｅａｒ（１９）』
として近々、始めますので宜しく、御贔屓の程、お願いしま
す！