binary search tree

#include<iostream>
// Binary Tree, as a non-linear data structure, operations like search/inseart/remove are different those for linear DT;
// we need a more detail rule (relationship, sequence) to help realize above operation.
// for operation find doesn't change relationship among items, it can be easily implemted.
struct node
{
    node(int key) :key_value(key), left(0), right(0){}
    int key_value;
    node *left;
    node *right;
};

class btree
{
public:
    btree();
    ~btree();

    void insert(int key);
    node *search(int key);
    void remove(int key);
    void destroy_tree();
    void preOrder(){ preOrder(root); }
    void midOrder();
    void postOrdr();
    void fromarrays(int *pre, int *mid, int len);
private:
    void destroy_tree(node *leaf);
    void insert(int key, node *leaf);
    node *search(int key, node *leaf);
    node *findparent(int key, node * leaf);
    void removeIn(int key, node *leaf);
    int min(node *leaf);
    node *root;
    void preOrder(node *leaf);
    void midOrder(node *leaf);
    void postOrdr(node *leaf);
　　// here leaf should be a poiter reference!!!
    void fromarrays(int *pre, int *mid, int len, node * &leaf);
};

btree::btree():root(0){}
btree::~btree(){ destroy_tree(root); }
void btree::destroy_tree(node * leaf)
{
    if (!leaf) return;
    destroy_tree(leaf->left);
    destroy_tree(leaf->right);
    delete leaf;
}

int btree::min(node *leaf){ if (leaf->left) return min(leaf->left); else return leaf->key_value; }
void btree::insert(int key, node * leaf)
{
    if (!leaf) return;
    if (key < leaf->key_value) leaf->left == NULL?leaf->left = new node(key):insert(key,leaf->left);
    else leaf->right == NULL?leaf->right = new node(key):insert(key,leaf->right);
    return;
}

void btree::insert(int key)
{
    if (!root) { root = new node(key); return; }
    else insert(key, root);
}

node * btree::search(int key, node* leaf)
{
    if (!leaf) return NULL;
    if (leaf->key_value == key) return leaf;
    return (key < leaf->key_value ? search(key, leaf->left):search(key,leaf->right));
}
node * btree::search(int key)
{
    return search(key, this->root);
}

void btree::remove(int key) { removeIn(key, root); }

// linked list: pointer of current node is stored in its parent's node!!!
void btree::removeIn(int key, node * &parent)
{
    if (!parent) return;
    if (key < parent->key_value) removeIn(key, parent->left);
    else if (key > parent->key_value) removeIn(key, parent->right);
    else
    {
        if (parent->left && parent->right){parent->key_value = min(parent->right);removeIn(parent->key_value,parent->right);}
        else if (parent->left){node * temp = parent;parent = parent->left;delete temp;}
        else if (parent->right){ node * temp = parent; parent = parent->right; delete temp; }
        else{delete parent;parent = NULL;}
    }
}

void btree::preOrder(node * leaf)
{
    if (!leaf) return;
    if (leaf->left) preOrder(leaf->left);
    std::cout << leaf->key_value;
    if (leaf->right) preOrder(leaf->right);
}

int findval(int *array, int val, int len)
{
    for (int i = 0; i < len; i++)
    {
        if (array[i] == val) return i;
    }
    return -1;
}
void btree::fromarrays(int * pre, int *mid, int len, node * leaf)
{
    if (!leaf || len == 0) return;
    int index = findval(pre, mid[0],len);
    if (index < 0 || index > len - 1) return;
    //std::cout << index;
    leaf->key_value = mid[0];
    if (index > 0)
    {
        leaf->left = new node(-1); fromarrays(pre, &mid[1], index, leaf->left);
    }
    if (index < len - 1) { leaf->right = new node(-1); fromarrays(&pre[index + 1], &mid[index + 1], len - index-1, leaf->right); }
}

void btree::fromarrays(int *pre, int *mid, int len)
{
    if (len > 0) root = new node(-1);
    fromarrays(pre, mid, len, root);
}
int main()
{
    int pre[] = { 4, 2, 8, 5, 1, 6, 3, 7, 9 };
    int mid[] = { 1, 2, 4, 5, 8, 3, 6, 7, 9 };
    btree tree;
    tree.fromarrays(pre, mid, 9);
    tree.preOrder();
    system("pause");
}

 the tree constructed by using fromarrays is not a binary search tree!!!

/*
btree tree;
tree.insert(1);
tree.insert(10);
tree.insert(13);
tree.insert(5);
tree.insert(9);
tree.insert(10);
tree.remove(1);
*/