二分查找法

二分搜索：在一个有序的数组中将数组一分为二，根据中点值与目标值的大小缩小查找区域，递归该过程。

// 二分查找法,在有序数组arr中,查找target
// 如果找到target,返回相应的索引index
// 如果没有找到target,返回-1
template<typename T>
int binarySearch(T arr[], int n, T target) {
    // 在arr[l...r]之中查找target
    int l = 0, r = n - 1;
    while (l <= r) {

        //int mid = (l + r)/2;
        int mid = l + (r - l) / 2;
        if (arr[mid] == target)
            return mid;

        if (arr[mid] > target)
            r = mid - 1;
        else
            l = mid + 1;
    }

    return -1;
}
template<typename T>
int __binarySearch2(T arr[], int l, int r, T target) {
    if (l > r)
        return -1;

    int mid = (l + r) / 2;
    if (arr[mid] == target)
        return mid;
    else if (arr[mid] > target)
        return __binarySearch2(arr, 0, mid - 1, target);
    else
        return __binarySearch2(arr, mid + 1, r, target);
}
template<typename T>
int binarySearch2(T arr[], int n, T target) {
    return __binarySearch2(arr, 0, n - 1, target);
}

二分搜索树：每个节点的左孩子小于根节点，每个节点的右孩子大于根节点

//二叉搜索树,包括左孩子和右孩子，键合值
template<typename Key, typename Value>
class BST {
private:
    struct Node {
        Key key;
        Value value;
        Node *left;
        Node * right;
        Node(Key key, Value value) {
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }
        Node(Node *node) {
            this->key = node->key;
            this->value = node->value;
            this->left = node->left;
            this->right = node->right;
        }
    };
    Node *root;
    int count;
public:
    BST(){
        root = NULL;
        count = 0;
    }
    ~BST() {
        destroy(root);
    }
    int size() { return count; }
    bool isEmpty() {
        return count == 0;
    }
    void insert(Key key, Value value) {
        root = insert(root, key, value);
    }
    bool contain(Key key) {
        return contain(root, key);
    }
    Value* search(Key key) {
        return search(root, key);
    }
    // 前序遍历
    void preOrder() {
        preOrder(root);
    }

    // 中序遍历
    void inOrder() {
        inOrder(root);
    }

    // 后序遍历
    void postOrder() {
        postOrder(root);
    }
    // 层序遍历
    void levelOrder() {

        queue<Node*> q;
        q.push(root);
        while (!q.empty()) {

            Node *node = q.front();
            q.pop();

            cout << node->key << endl;

            if (node->left)
                q.push(node->left);
            if (node->right)
                q.push(node->right);
        }
    }
    // 寻找最小的键值
    Key minimum() {
        assert(count != 0);
        Node* minNode = minimum(root);
        return minNode->key;
    }

    // 寻找最大的键值
    Key maximum() {
        assert(count != 0);
        Node* maxNode = maximum(root);
        return maxNode->key;
    }

    // 从二叉树中删除最小值所在节点
    void removeMin() {
        if (root)
            root = removeMin(root);
    }

    // 从二叉树中删除最大值所在节点
    void removeMax() {
        if (root)
            root = removeMax(root);
    }
    // 从二叉树中删除键值为key的节点
    void remove(Key key) {
        root = remove(root, key);
    }
private:
    // 向以node为根的二叉搜索树中,插入节点(key, value)
    // 返回插入新节点后的二叉搜索树的根
    Node* insert(Node* node, Key key, Value value) {
        if (node == NULL){
            count++;
            return new Node(key, value);
        }
        if (key == node->key) {
            node->value = value;
        }
        else if (key < node->key)
            node->left = insert(node->left, key, value);
        else    // key > node->key
            node->right = insert(node->right, key, value);
        return node;
    }
    // 查看以node为根的二叉搜索树中是否包含键值为key的节点
    bool contain(Node* node, Key key) {

        if (node == NULL)
            return false;

        if (key == node->key)
            return true;
        else if (key < node->key)
            return contain(node->left, key);
        else // key > node->key
            return contain(node->right, key);
    }

        // 在以node为根的二叉搜索树中查找key所对应的value
    Value* search(Node * node, Key key) {
        if (node == NULL) {
            return NULL;
        }
        if (key == node->key) {
            return &(node->value);
        }
        else if (key < node->key) {
            return search(node->left, key);
        }
        else {
            return search(node->right, key);
        }
    }
    void preOrder(Node * node) {
        if (node != NULL) {
            cout << node->key << endl;
            preOrder(node->left);
            preOrder(node->right);
        }
    }
    void inOrder(Node * node) {
        if (node != NULL) {
            preOrder(node->left);
            cout << node->key << endl;
            preOrder(node->right);
        }
    }
    void postOrder(Node * node) {
        if (node != NULL) {
            preOrder(node->left);
            preOrder(node->right);
            cout << node->key << endl;
        }
    }
    void destroy(Node* node) {

        if (node != NULL) {
            destroy(node->left);
            destroy(node->right);
            delete node;
            count--;
        }
    }
    Node* minmum(Node *node) {
        if (node->left == NULL) {
            return node;
        }
        minmum(node->left);
    }
    // 在以node为根的二叉搜索树中,返回最大键值的节点
    Node* maximum(Node* node) {
        if (node->right == NULL)
            return node;

        return maximum(node->right);
    }
    Node* removeMin(Node *node) {
        if (node->left == NULL) {

            Node* rightNode = node->right;
            delete node;
            count--;
            return rightNode;
        }

        node->left = removeMin(node->left);
        return node;
    }
    Node* removeMax(Node *node) {
        if (node->right == NULL) {

            Node* leftNode = node->left;
            delete node;
            count--;
            return leftNode;
        }
        node->right = removeMin(node->right);
        return node;
    }
    Node* remove(Node *node, Key key) {
        if (node == NULL) {
            return NULL;
        }
        if (node->key == key) {
            if (node->left == NULL) {//要删除节点左节点为0也就是最小值节点
                Node *rightNode = node->right;
                delete node;
                count--;
                return rightNode;
            }
            if (node->right== NULL) {//要删除节点左节点为0也就是最小值节点
                Node *leftNode = node->left;
                delete node;
                count--;
                return leftNode;
            }
            Node *successor = new Node(minmum(node->right));//找到后继节点
            count++;
            successor->right = removeMin(node->right);//删除后继位置元素，将其放到合适的位置
            successor->left = node->left;
            delete node;
            count--;
            return successor;
        }
        else if (key < node->key) {
            node->left = remove(node->left, key);
            return node;
        }
        else {
            node->right = remove(node->right, key);
            return node;
        }

        remove(node, key);
    }
};

void preOrder(Node * node) {
        if (node != NULL) {
            cout << node->key << endl;
            preOrder(node->left);
            preOrder(node->right);
        }
    }
    void inOrder(Node * node) {
        if (node != NULL) {
            preOrder(node->left);
            cout << node->key << endl;
            preOrder(node->right);
        }
    }
    void postOrder(Node * node) {
        if (node != NULL) {
            preOrder(node->left);
            preOrder(node->right);
            cout << node->key << endl;
        }
    }