再帰非再帰後のシーケンスのバイナリ、成果、プリアンブル、

バイナリツリーの問題：

#include <iostreamの> 
する#include <ベクトル> 
の#include < ストリング > 
の#include <sstream提供> 
の#include <スタック>
 使用して 名前空間STD;
 構造体BiTreeNode {
     チャーデータ、
     構造体 BiTreeNode * left_child、
     構造体 BiTreeNode * right_child; 
}; 

int型 N = 0 ; 

無効（BiTreeNode＆T *、CreateBiTree チャー{[]配列） 
  // バイナリツリーノードの入力シーケンスに値（文字）で、*文字は空のツリーを表し、 
  // 構成バイナリテーブルは、二分木Tを示し 
 CHAR CH =配列[N]; 
 N = N + 1 ; 
  IF（CH == ' * '）T = NULL;
  他{ 
  T = 新しい新しい BiTreeNode; // 新しいサブツリーを作成 
  T->データ= CH; 
  CreateBiTree（T-> left_child、アレイは）; // 再帰左サブツリー作成 
  CreateBiTree（T-> right_child、アレイ）; //は再帰的に右サブツリーを作成
} 
} // CreateTree 
// 再帰プレオーダー
空隙 pre_order_traverse（BiTreeNode *＆T）{
     / / プレオーダー
    IF （T）{ 
        COUT << T-> <<データ" " ; 
        Pre_order_traverse（T - > left_child）; 
        pre_order_traverse（T - > right_child）; 
    } 
} 

// プレオーダー非再帰; 
ボイド pre_order_traverse_no_recurse（BiTreeNode *＆T）{
     // バイナリツリーの非再帰先行順走査 
    スタック<BiTreeNode *> S; 
    BiTreeNode * P = T; 

    // ポインタPが空かないときにコールスタックが空サイクルでない
    一方（P = nullptr A ||！s.empty（））{
         ながら（！p = nullptr A）{ 
            COUT << P - >データ<< "  " ; 
            s.push（P）。
            p個の = P - >left_child。
        } 
        もし（！s.empty（））{ 
            P = s.top（）。
            s.pop（）; 
            P = P - > right_child。
        } 
    } 
} 

// 递归中序遍历
空隙 in_order_traverse（BiTreeNode *＆T）{
     // 中序遍历
    場合（T）{ 
        in_order_traverse（T - > left_child）。
        coutの << T->データ<< "  " ; 
        in_order_traverse（T - > right_child）。
    } 
} 

//中序遍历非递归
 right_child。ボイド in_order_traverse_no_recurse（BiTreeNode *＆T）{ 
    スタック <BiTreeNode *> S。
    BiTreeNode * P = T; 

    一方、（P = nullptr ||！s.empty（））{
         一方（P =！nullptr）{ 
            s.push（P）。
            P = P - > left_child。
        } 

        もし（！s.empty（））{ 
            P = s.top（）。
            coutの << p型>データ<< "  " ; 
            s.pop（）; 
            P = P-> 
        } 
    } 
}

// 再帰プレオーダー後
ボイド pos_order_traverse（BiTreeNode *＆T）{
     // プレオーダー
    IF （T）{ 
        pos_order_traverse（T - > left_child）; 
        pos_order_traverse（T - > right_child）; 
        COUT << T-> <<データ"  " ; 
    } 
} 

// 予約限定バック非再帰的
空隙 pos_order_traverse_no_recurse（BiTreeNode *＆T）{ 
    スタック <BiTreeNode *> S; 
    BiTreeNode * P = T; 
    BiTreeNode * PP =！（P = nullptr ||！ヌル;
    一方s.empty（））{
         ながら！（P = nullptr）{ 
            s.push（P）。
            P = P - > left_child。
        } 
        もし（！s.empty（））{ 
            P = s.top（）。
            もし（P-> right_child == NULL || P-> right_child == PP）{ 
            COUT << P->データ<< "  " 。
            s.pop（）; 
            PP = P; 
            P = NULL; 
        } 
        他{ 
            P = P->right_child; 
        }
    } 
    } 
} 

int型のmain（）{
 char型の配列[] = " ABCE *** D ** MN * K ** O * JH *** " 。
BiTreeNode * T; 
CreateBiTree（T、アレイ）
// pre_order 
裁判所未満<< " pre_order_traverse " << てendl; 
pre_order_traverse（T）。
coutの << てendl; 
裁判所未満 << " pre_order_traverse_no_recurse " << てendl; 
pre_order_traverse_no_recurse（T）。
coutの << てendl;

" in_order_traverse " << てendl; 
in_order_traverse（T）。
coutの << てendl; 
裁判所未満 << " in_order_traverse_no_recurse " << てendl; 
in_order_traverse_no_recurse（T）。
coutの << てendl; 

// pos_orderの 
はcout << " pos_order_traverse " << てendl; 
pos_order_traverse（T）。
coutの << てendl; 
裁判所未満 << " pos_order_traverse_no_recurse " << てendl; 
pos_order_traverse_no_recurse（T）。
コスト <<てendl; 

リターン 0 ; 
}