訓練データ構造(III)---バイナリツリー幅

説明】【課題
バイナリツリーアルゴリズムの幅(ノード、その層の数が最も多いノード数)の貯蔵、調製用バイナリーリスト構造に関する。

[入力]の2行を形成し、最初の行は、バイナリツリーの拡張シーケンス先行順走査です。
[フォーム]バイナリツリーの出力の幅。
サンプル入力] [AB#D ## C ##
[]サンプル出力

main.cppにファイル

書式#include <iostreamの> 
の#include " BiTree.h " 
使用して 名前空間はstdを、

int型のmain()
{ 
    BiTree < チャー > T。
    COUT << t.TreeWidth()。
}

 

(バイナリ法上のいくつかの質問で)BiTree.hファイル

BITREE_H_INCLUDED #ifndefの
 に#define BITREE_H_INCLUDED 
の#include <キュー>
 使用して 名前空間STD;
 // 定義されたノード 
テンプレート<データ型typenameです> 構造体BiNode 
{ 
    データ型のデータを、
    BiNodeを <データ型> lchild *、* rchild; 
}; 
テンプレート <型名データ型>
 クラスBiTree 
{ パブリック// ビルド機能、バイナリ1     BiTree()
    { 
        ルート = クリート(); 
    } // デストラクタリリースノードの記憶スペース
    {





     BiTree() 
        リリース(ルート); 
    } 

    // プレオーダートラバーサルバイナリツリーの
    空隙プレオーダー()
    { 
        プレオーダー(ルート); 
    } 

    // プレオーダーバイナリツリー
    ボイド順序どおり()
    { 
        順序どおり(ルート); 
    } 

    // 後順バイナリツリー
    ボイド後順( )
    { 
        後順(ルート); 
    } 

    // 数は、Xがいるか否かを判定する
    BOOL ExistX(データ型がX)
    { 
        リターンExistX(ルート、X); 
    } 

    // 層ノードXが配置されている
    int型XLay(データ型がX)
    { 
        返す(XLayをルート、X)。
    } 

    //求二叉数的宽度
    INT ツリー幅()。
プライベート
    BiNode <データ型> * クリート();
    無効リリース(BiNode <データ型> * BT)。
    予約限定(BiNode <データ型> * BT)。
    順序どおり(BiNode <データ型> * BT)。
    無効後順(BiNode <データ型> * BT)。
    BOOL ExistX(BiNode <データ型> * BT、データ型X)。
    int型 XLay(BiNode <データ型> * BT、データ型x)は; 
    BiNode <データ型> * ルート。

}。

// 构建函数、建立一颗二叉树 
テンプレート<typenameにはDataType> <データ型> * BiTree <データ型> ::クリート()
{ 
    BiNode <データ型> * BT;
     チャーCH; 
    CIN >> CH;                     // 入力ノードデータ情報
    IF(CH == ' ' 
        BT = nullptr A;     // 空のツリーの構築
    
    { 
        BT = 新しい新しい BiNode <データ型> ; 
        BT - >データ= CH; 
        BT - > lchild =クリートを();    // 確立再帰左サブツリー 
        BT-> rchild =クリート();    //再帰右部分木確立
    }
     リターンをBT; 
} 

// デストラクタリリースノードのストレージスペース 
テンプレート<データ型をtypenameです> 無効 BiTree <データ型> ::リリース(BiNode <データ型> * BT)
{ IF(BT == nullptr a)の
         リターン;
     
    { 
        リリース(BT - > lchild); 
        リリース(BT - > rchild);
         削除BT; 
    } 
} // 前順トラバーサルバイナリツリーの 
テンプレート<型名はDataType> のボイド BiTree <データ型> ::予約限定(BiNode <データ型> * BT)
{ IF

    



    (BT == nullptr)
         のリターン;
    他の
    { 
        coutの << BT-> データ; 
        予約限定(BT - > lchild); 
        予約限定(BT - > rchild); 
    } 
} 

// 中序遍历二叉树 
テンプレート<型名データ型> ボイド BiTree <データ型> ::順序どおり(BiNode <データ型> * BT)
{ 場合(BT == nullptr)
         のリターン;
    
    { 
        順序どおり(BT - > lchild)。
        coutの << BT-> データ; 
        順序どおり(BT

     - > rchild); 
    } 
}

 // 后序遍历二叉树 
テンプレート<型名データ型> ボイド BiTree <データ型> ::後順(BiNode <データ型> * BT)
{ 場合(BT == nullptr)
         のリターン;
    
    { 
        後順(BT - > lchild)。
        後順(BT - > rchild); 
        coutの << BT-> データ; 
    } 
} // 判断是否存在X 
テンプレート<型名データ型> BOOL BiTree <データ型> :: ExistX(BiNode <データ型> * BT、データ型X)
{ もし

    



    (BT == nullptr)
         のリターン ;
    そう であれば(BT->データ== X)
    { 
        戻り 
    } 
    
    { 
        場合(ExistX(BT-> lchild、X))
             を返す もし(ExistX(BT-> rchild、x))が
             復帰 
    } 
    を返す 
} 

// 存在节点X的层数 
テンプレート<型名データ型> INT BiTree <データ型> :: XLay(BiNode <データ型> * BT、データ型X)
{もし

    int型ベビーベッド= 0 ;
    (BT == nullptr)
         戻りベッド。
    そう であれば(BT->データ== X)
    { 
        COT = 1 リターンベビーベッド; 
    } 
    
    { 
        場合(XLay(BT-> lchild、X))
        { 
            COT = XLay(BT-> lchild、X)+ 1 リターンベビーベッド; 
        } 
        であれば(XLay(BT-> rchild、X)){ 
            COT = XLay(BT-> rchild、X)+ 1 リターンベビーベッド; 
        } 
    }
    戻りCOT; 
} 

テンプレート <型名データ型>
 INT BiTree <データ型> ::ツリー幅()
{ 
    キュー <BiNode <データ型> *> Q;   // ノードの種類のタイプのリクエストキュー< BiNode <データ型> *> 
    INT W;
     IF(ルート== NULL)   // ツリーがゼロの空の幅
        戻り 0 ;
     
    { 
        Q.push(ルート);    // ルートエンキュー 
        W = 1 ;
         INT maxW;        / /に格納された最大の整数変数を設定 
        maxw = W;
         しばらく(Q.empty()!)           //は、キューが完全にトラバースを表す空であるか否かを判断
        {
             ためINT I = 0 ; <; I ++ W I)の     // ノードは、その子ノードがエンキュー、デキュー
            {
                 IF lchild( - )(Q.frontを> != NULL)
                Q.push(Q.front() - > lchild);
                 IF(Q.front() - > rchild =!NULL)
                Q.push(Q.front() - > rchild); 
                Q.pop( );     // ノードがデキュー

            } 
            W = Q.size();
             IF(maxW <W)   //各maxW最大のことを保証します
                maxw = W。
        } 
        戻りmaxw。
    } 
} 
#endifの // BITREE_H_INCLUDED

 

おすすめ

転載: www.cnblogs.com/DullRabbit/p/12559131.html
おすすめ