排序二叉树（BST）

/*
    排序二叉树 BST
    时间复杂度为 LOG n
                    2
*/

#include <iostream>
#include <stack>
using namespace std;

typedef struct node
{
    int value;
    struct node *left,*right;
}BST;

void CreateBST(BST* &root,int arr[],int length)
{
    if(arr == NULL || length <= 0)  return ;
    stack<BST*> stack_bst;
    int k = 0;  BST* node = NULL; BST * tmp =NULL;     
    root = new BST;
    root->left = NULL; root->right = NULL; root->value = arr[k]; //创建根节点
    stack_bst.push(root);
    
    for(int i=1;i<length;i++){     //新节点的添加
        node = new BST;
        tmp = root;
        node->left = NULL; node->right = NULL; node->value = arr[i];
        while(tmp){    
            if(node->value < tmp->value){    //当新节点的数据小于当前节点的数据的时候  左走
                if(tmp->left == NULL){       //当当前节点的左为空时  直接添加新的节点为最左的新节点
                    tmp->left = node;
                    stack_bst.push(node);
                    break;
                }
                tmp = tmp->left;
            }
            else if(node->value > tmp->value){    //当新节点的数据大于当前节点的数据的时候  向右走
                if(tmp->right == NULL){           //当前节点的有节点为空 直接将新的节点加入二叉树  形成最右的节点
                    tmp->right = node;
                    stack_bst.push(node);
                    break;
                }
                tmp= tmp->right;
            }
            else{        //当数据错误时  清理之前创建的节点 （有误值得是数据中出现相同的数据 这样的数据是不合法的  如果想要解决这种问题，在BST结构中添加用于计数的字段用于处理数据中的重复数据）
                cout<<"数据有误";
                while(!stack_bst.empty()){
                    tmp = stack_bst.top();
                    stack_bst.pop();
                    delete tmp ;
                    tmp = NULL;
                }
                root = NULL;
                return ;
            }
        }
    }
}
 
void Traver_x(BST* root)   //先序遍历
{
    if(root == NULL) return ;
    cout<<root->value<<" ";
    Traver_x(root->left);
    Traver_x(root->right);
}

void Traver_z(BST* root)   //中序遍历
{
    if(root == NULL)  return ;
    Traver_z(root->left);
    cout<<root->value<<" ";
    Traver_z(root->right);
}

void Traver_h(BST* root)   //后序遍历
{
    if(root == NULL)  return ;
    Traver_h(root->left);
    Traver_h(root->right);
    cout<<root->value<<" ";
}

void f_Traver_h(BST* root)   //非递归后序
{
    if(root == NULL)  return ;
    stack<BST*> stack_bst;
    int tag = 0;
    BST* node = NULL;
    do{
        while(root){
            stack_bst.push(root);
            root = root->left;
        }
        tag =1; node = NULL;
        while(!stack_bst.empty() && tag ){
            root = stack_bst.top();
            if(root->right == node){
                cout<<root->value<<" ";
                node = root;
                stack_bst.pop();
            }
            else{
                root = root->right;
                tag = 0;
            }
        }
    }while(!stack_bst.empty());
}

int main()
{
    int arr[] = {10,6,2,4,66,7,1};
    BST * root = NULL;
    CreateBST(root,arr,sizeof(arr)/sizeof(int));
    Traver_x(root);
    cout<<endl<<"--------------------------我是分割线------------------------------------"<<endl;
    Traver_z(root);
    cout<<endl<<"--------------------------我是分割线------------------------------------"<<endl;
    Traver_h(root);
    cout<<endl<<"--------------------------我是分割线------------------------------------"<<endl;
    f_Traver_h(root);
    cout<<endl;
    system("pause");
    return 0;
}