入力後続とシーケンスは、バイナリツリーを構築し、バイナリツリーの出力シーケンス、プリアンブル、配列中、構造通過後、二分木構築入力シーケンスおよび順序で、および出力シーケンスを、二分木のプリアンブル、順番に、構造を通過した後

 

/ * 
入力最初のシーケンスとするために、二分木を構築し、バイナリツリーの出力シーケンス、プリアンブル、配列中、構造を通過した後
、入力シーケンス後ために、二分木を構築し、バイナリツリー・シーケンスを出力する、プリアンブル、配列中、構造を通過した後
* / 
の#include <stdio.hに> 
する#include < 文字列・H> 
の#include <malloc.hを> 
のtypedef 構造体ノード{
     チャーデータ、
     構造体ノード* lchild、
     構造体ノード* rchild; 
} B木; 
B木 * createPre（CHAR *プリ、CHAR * において、INT N-）{
     IF（N - <= 0）戻りNULL;
     CHAR *P;
    int型のk; 
    B木 * B; 
    B =（B木*）はmalloc（はsizeof （B木））。
    B - >データ= * 前。
    用（P = であり; p < における + N、P ++ ）
         場合（* P == * PRE）
             ブレーク。
    K = P- において、
    B - > lchild = createPre（プリ+ 1、において、K）。
    B - > rchild = createPre（プリ+ K + 1、P + 1、NK- 1 ）。
    リターンB; 
}
B木。* createPost（CHAR *後、チャー * において、INT N）{
     場合（N <= 0）戻りNULL。
    char * P、R。
    int型のk; 
    R = *（ポスト+ N- 1 ）。
    B木 * B; 
    B =（B木*）はmalloc（はsizeof （B木））。
    B - >データ= R。
    用（P = であり; p < における + N、P ++ ）
         場合（* P == R）
             ブレーク
    K = P-で、
    B - > lchild = createPost（ポスト、中、K）。
    B - > rchild = createPost（ポスト+ K、P + 1、NK- 1 ）。
    リターンB; 
} 
ボイドプリソート（B木* B）{ 
    B木 * P、* ST [ 10 ]。
    int型のトップ= - 1 ; 
    P = B。
    一方、（！p = NULL ||トップ> - 1 ）{
         一方（P =！NULL）{ 
            のprintf（" ％のC "、P-> データ）。
            トップ++ ; 
            ST [トップ] = P。
            P = P - > lchild。
        } 
        もし（トップ> - 1 ）{ 
            P = ST [トップ]。
            トップ - ; 
            P = P - > rchild。
        } 
    } 
    のprintf（" \ n " ）; 
} 
ボイド insort（B木* B）{ 
    B木 * P、* ST [ 10 ]。
    int型のトップ= - 1 ; 
    P = B。
    同時にした（p = NULL ||トップ>！ -1 ）{
         ながら！（P = NULL）{ 
            トップ ++ 。
            ST [トップ] = P。
            P = P - > lchild。
        } 
        もし（トップ> - 1 ）{ 
            P = ST [トップ]。
            トップ - ; 
            printf（" ％のC "、P-> データ）。
            P = P - > rchild。
        } 
    } 
    のprintf（" \ n " ）; 
} 
無効postsort（B木* B）{ 
    B木 * P、* ST [ 10 ]。
    INT T1 = - 1、T2 = - 1、タグ[ 10 ]、F。
    P = B。
    一方、（！p = NULL || T1> - 1 ）{
         場合（！p = NULL）{ 
            T1 ++ 。
            ST [T1] = P。
            T2 ++ ; 
            [T2]タグ = 1 。
            P = P - > lchild。
        } 他{ 
            P =ST [T1]。
            T1 NULL; - ; 
            F = タグ[T2]。
            T2 - ;
            もし（F == 1 ）{ 
                T1 ++ 。
                ST [T1] = P。
                T2 ++ ; 
                [T2]タグ = 2 。
                P = P - > rchild。
            } 他{ 
                のprintf（" ％のC "、P-> データ）。
                P = 
            } 
        } 
    } 
    のprintf（" \ n " ）; 
} 
ボイド censort（B木* B）{ 
    B木 * P、* QU [ 10 ]。
    INT F = - 1、R = - 1 。
    P = B。
    R ++ ; 
    QU [R] = P。
    一方、（！F = R）{ 
        F =（F + 1）％10 。
        P = QU [F]。
        printf（" ％のC "、P-> データ）。
        もし（P-> lchild！= NULL）{ 
            R =（R + 1）％10 。
            QU [R] = P-> lchild。
        } 
        であれば（P-> rchild！= NULL）{ 
            R =（R + 1）％10 。
            QU [R] = P-> rchild。
        } 
    } 
    のprintf（" \ n " ）; 
} 
int型のmain（）
{ 
    char型プリ[ 100 ] に [ 100 ]、ポスト[ 100 ]。
    int型のn = 7 。
    B木 * B; 
    （前）を取得します。
    （取得中）。
    B = createPre（前、中にN、）; 
    censort（B）。
    プリソート（B）。
    insort（B）。
    postsort（B）。
    （ポスト）を取得します。
    （取得中）。
    B = createPost（ポスト、中、N）
    censort（B）。
    プリソート（B）。
    insort（B）。
    postsort（B）。
    リターン 0 ; 
}