C ++ビルドのバイナリ検索ツリー

バイナリ検索ツリー

データを挿入するときに、バイナリ検索ツリーを参照し、ルートノードを比較し、木の大きさは、順序付けられた位置に検索し、格納されました。

実装

ツリーのルートに比べツリーにデータ、左側に大きな言葉（右側）、右（左）の小さな言葉。

#include <iostreamの> 
する#include <ベクトル> 
 使用して 名前空間STD; 
typedefは構造体STD 
{ 
    INT INUM、
     構造体 STD * 左、
     構造体 STD * 右; 
}ツリー、

ベクトル <ベクトル< INT >> prder; //のレベルを横断します 
 / / 空の木の作成 
ツリーCreateTreeを*（int型iNumroot）;
 // 第二に、データの挿入
、ボイド InsertTree（木ヘッド*、int型のn）;
 // 第三、ノード削除 
ツリー*削除（木ヘッド*、int型N-）。 
 //第四には、レベルを通過する 
ベクトル<ベクトル< int型 >> Layer_Tree（木* ヘッド）;
 無効 layertree（木ヘッド*、int型のn）; 
 // IV.2、出力データ
のボイドポイント（）; 
 int型のmain（）
{ 
    ツリー * ルート;
     INT iNumroot;
     INT INUMBER; 
    
    // 入力根 
    COUT << " 入力根：" << ENDL; 
    CIN >> iNumroot; 
    ルート = CreateTree（iNumroot）;
     // 入力データ数 
    COUT << 「入力データ番号："<< ENDL; 
    CIN >> INUMBER; 
    COUT << " 入力データ：" ;
     のための（INT I = 0 ; I <INUMBER; I ++ ）
    { 
        int型A; 
        CIN >> A; 
        InsertTree（ルートA）; 
    } 
    // 削除ノード 
    COUT << " 削除する入力ノード：" ;
     INT M; 
    CIN >> M; 
    ルート = 削除（ルート、M）;
     // レベルの出力データ 
    prder = Layer_Tree（ルート）。
    ポイント（）; 
    リターン 0 ; 
    
} 
ツリー * CreateTree（INT iNumroot）
{ 
    ツリー * ヘッド。
    ヘッド = 新しいツリー。
    （ *ヘッド）.iNum = iNumroot。
    ヘッド - >左= NULL; 
    ヘッド - >右= NULL;
    返す頭を。
} 
ボイド InsertTree（ツリー*ヘッド、INT N）
{ 
    場合（N>頭部> INUM）
    { 
        場合（頭部> 右）
        { 
            InsertTree（ヘッド- >ツリー。右、N）。
        } 
        他
        { 
            木 *新しい= 新しいツリー。
            （ *新）.iNum = N。
            新 - >左= NULL; 
            新 - >右= NULL; 
            ヘッド - >右= 新;
            リターン; 
        } 
    } 
    他
    { 
        場合（頭部は> 左）
        { 
            InsertTree（ヘッド - > 左、N）。
        } 
        他
        { 
            ツリー *新= 新しいです
            （*新）.iNum = N; 
            新 - >左= NULL; 
            新 - >右= NULL; 
            ヘッド - >左= 新しいです。
            リターン; 
        } 
    } 
} 
ベクトル <ベクトル< int型 >> Layer_Tree（木* ヘッド）
{ 
    場合（ヘッド！）戻りprder。
    layertree（ヘッド、0 ）; 
    
    リターンprder。
} 
ツリー *削除（木*ヘッド、int型のn）
{ 
    場合（！ヘッド） 
    {
        はcout << "删除的节点不存在！" << てendl; 
    } 
    であれば（N ==頭部> INUM）
    { 
        場合（頭部が>> &&頭部を左、右）
        { 
            ツリー * CUR =頭部> 右。
            一方、（cur-> INUM！= NULL）
            { 
                CUR = cur-> 左。
            } 
            ヘッド - > INUM = cur-> INUM。
            ヘッド - >右=の削除（頭部>右、cur-> INUM）; 
        } 
        それ以外の 場合（！頭部には> &&左！
        {
            リターンNULL ;
        } 
        他
        { 
            ヘッド =（頭部>左== NULL）頭部>権利：頭部> 左。
        } 
    } 
    そう であれば（N>頭部> INUM）
    { 
        ヘッド - >右=削除（頭部> 右、N）。
    } 
    他
    { 
        ヘッド - >左=削除（頭部> 左、N）。
    } 
    戻りヘッドと、
} 
無効 layertree（木*ヘッド、int型のn）
{ 
    場合（！ヘッド）のリターン;
    もし（N> = prder.size（））
    {
        ベクトル < int型 > X; 
        prder.push_back（X）。
    } 
    prder [N] .push_back（ヘッド - > INUM）。
    layertree（ヘッド - >左、N + 1 ）。
    layertree（ヘッド - >右、N + 1 ）。
} 
ボイドポイント（）
{ 
    ため（intは iは= 0 ; I <prder.size（）; I ++ ）
    { 
        場合（prder [I] .empty（））
        { 
            COUT << " N " << "  " 。
        } 
        のために（INT J = 0 ; J <prder [I] .size（）; J ++ ）
        { 
            COUT << prder [I] [J] << "  " 。
        } 
        COUT << ENDL。
    } 
}