비 재귀 이진 정렬 트리

사용법 #include <iostream> 
#INCLUDE < 문자열 > 
#INCLUDE <CString을> 
#INCLUDE <cmath> 
#INCLUDE <알고리즘> // 非递归
사용  공간이 수 std;
int로 A [ 1000 ];
INT Q = 0 ;
INT 플래그 = 0 ;
타입 정의 구조체 BiTNode {
     INT의 데이터;
    구조체 BiTNode lchild * * rchild;
    INT 카운트;
} BiTNode, * BiTree;
보이드 InsertBST (BiTree & T, INT의 E)
{
    BiTNode * CUR = T;
    BiTree들 = 새로운 BiTNode;
    (S) -> 데이터 = E;
    이야 -> 카운트 = 0 ;
    이야 -> lchild = NULL;
    이야 -> rchild = NULL;
    만약 (! T)
    {

        T의 = S;
    }
    그밖에
    {
        BiTNode * 부모 = T;
        동안 (현재! = NULL)
        {
            부모 = CUR;
            경우 (E> 부모 -> 데이터)
                CUR = 학부모> rchild;
            그 밖의 
                경우 (즉 <부모 -> 데이터)
                    CUR = 학부모> lchild;
                다른 
                    경우 (예 == 부모 -> 데이터)
                    {
                        부모 -> 카운트 ++ ;
                        플래그 = 1 ;
                        휴식 ;
                    }
        }
        경우 (E> 부모 -> 데이터)
            부모 -> rchild = S;
        경우 (즉 <부모 -> 데이터)
            부모 -> lchild = S;
    }
}
보이드 CreatBST (BiTree & T, INT N, INT V [])
{
    T = NULL;
    위한 ( INT 난 = 0 ; I <N; I ++ )
    {
        InsertBST (T, V [I]);
    }
}
INT 의 [ 1000 ];
int로 난 = 0 ;
보이드 InorderTraverse (BiTree T, INT의 E)
{
    경우 (T! = NULL)
    {
        
        InorderTraverse (T -> lchild, 전자);
        경우 (T-> 데이터! = E)
        {
            COUT << "  " << T-> 데이터;
            S [I] = T-> 카운트;
            내가 ++ ;
        }
        InorderTraverse (T -> rchild, 전자);
    }
}
int 형 ) (주
{
    INT N;
    동안 (N, N >> CIN &&! = 0 )
    {
        Q = 0 ;
        BiTree T;
        INT의 V [ 1000 ];
        플래그 = 0 ;
        위한 ( INT 난 = 0 ; I < 100 ; I ++ )
            S [I] = 0 ;
        위한 ( INT 난 = 0 ; I <N; I ++ )
        {
            CIN >> V [I];
        }
        CreatBST (T, N, V);
        int로 을;
        CIN >> a 및
        InsertBST (T, A);
        BiTree의 피;
        P = T;
        반면 (P-> lchild)
        {
            P = P-> lchild;
        }
        COUT << P-> 데이터;
        S [ 0 ] = P-> 카운트;
        내가 ++ ;
        INT E = P-> 데이터;
        InorderTraverse (T, E);
        COUT << ENDL;
        INT m = 0 ;
        경우 (플래그 == 0 )
            m = N + 1 ;
        다른 
            m = N;
        COUT << S [ 0 ];
        위한 ( INT 난 = 1 ; I <m을; I ++ )
        {
            COUT << "  " << S [I];
        }
        COUT << ENDL;
    }
    반환  0 ;
}

1