算法基础 典型题（六）二分搜索 与 二分查找树

记录算法基础题思路：

step1

插入位置查找: https://leetcode-cn.com/problems/search-insert-position/submissions/

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例:
输入: [1,3,5,6], 5
输出: 2

    int searchInsert(vector& nums, int target) {
        /* 二分查找方法改造, 适用不存在场景 */
        /* 1 左插入场景：假设target < nums[mid] 但 > nums[mid - 1](边界0), 在mid插入 */
        /* 2 右插入场景：假设target > nums[mid] 但 < nums[mid + 1](边界size - 1), 在mid + 1 插入 */      
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = (end + begin) / 2;
            if (target == nums[mid]) {
                return mid;
            } else if (target < nums[mid]) {
                if ((mid == 0) || target > nums[mid - 1]) {
                    return mid;
                }
                end = mid - 1;
            } else {
                if ((mid == nums.size() - 1) || target < nums[mid + 1]) {
                    return mid + 1;
                }
                begin = mid + 1;
            }
        }
        return 0; /* 实际不会进来 */
    }

区间查找：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/submissions/

给定一个按照升序排列的整数数组 nums，和一个目标值target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

public:
    vector searchRange(vector& nums, int target) {
        /* 基于二分查找做区间改造，做二次查找分别找左右端点 */
        /* target == nums[mid] && target > nums[mid - 1] 左端点， 边界0*/
        /* target == nums[mid] && target < nums[mid + 1] 左端点， 边界size -1 */
        vector res;
        res.push_back(find_left_pos(nums, target));
        res.push_back(find_right_pos(nums, target));
        return res;
    }
private:
    int find_left_pos(vector& nums, int target) {
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = (end + begin) / 2;
            if (target == nums[mid]) {
                if (mid == 0 || nums[mid - 1] < target) {
                    return mid;
                }
                end = mid - 1;
            } else if (target < nums[mid]) {
                end = mid - 1;
            } else if (target > nums[mid]) {
                begin = mid + 1;
            }
        }
        return -1;
    }
    int find_right_pos(vector& nums, int target) {
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = (end + begin) / 2;
            if (target == nums[mid]) {
                if ((mid == nums.size() - 1) || nums[mid + 1] > target) {
                    return mid;
                }
                begin = mid + 1;
            } else if (target < nums[mid]) {
                end = mid - 1;
            } else if (target > nums[mid]) {
                begin = mid + 1;
            }
        }
        return -1;
    }

旋转数组查找：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/submissions/

假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例:
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

    int search(vector& nums, int target) {
        /* 二分查找改进补充落在旋转区间方式, 如nums[begin]>nums[end]为旋转区间，否则为递增区间*/
        int begin = 0;
        int end = nums.size() - 1;
        while (begin <= end) {
            int mid = (end + begin) / 2;
            if (target == nums[mid]) {
                return mid;
            } else if (target < nums[mid]) {
                /* 如果begin到mid为递增区间, mid到end为旋转区间*/
                if (nums[begin] < nums[mid]) {
                    if (target >= nums[begin]) { // 递增区间有
                        //end = mid - 1; //递增区间有(优化为下面一句, 避免反复空间判断)
                        return normal_binary_search(nums, begin, mid - 1, target);
                    } else { //递增区间没有，在旋转区间找 
                        begin = mid + 1;
                    }
                /* 如果begin到mid为旋转区间，mid到end为递增区间 */
                } else if (nums[begin] > nums[mid]) {
                    end = mid - 1; // 递增区间没，在旋转区间找
                } else { //nums[begin] == nums[mid]，mid和begin值相同
                    begin = mid + 1;
                }
            } else if (target > nums[mid]) {
                /* 如果begin到mid为递增区间, mid到end为旋转区间*/
                if (nums[begin] < nums[mid]) {
                    begin = mid + 1; //递增区间没有，在旋转区间找 
                /* 如果begin到mid为旋转区间，mid到end为递增区间 */
                } else if (nums[begin] > nums[mid]) {
                    if (target <= nums[end]) {
                        //begin = mid + 1; //递增区间有(优化为下面一句, 避免反复空间判断)
                        return normal_binary_search(nums, mid + 1, end, target);
                    } else {
                        end = mid - 1; // 递增区间没有，在旋转区间找
                    }
                } else { //nums[begin] == nums[mid]，mid和begin值相同
                    begin = mid + 1;
                }
            }
        }
        return -1;
    }

二叉查找树编码解码：https://leetcode-cn.com/problems/serialize-and-deserialize-bst/submissions/

序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。
设计一个算法来序列化和反序列化二叉搜索树。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。
编码的字符串应尽可能紧凑。

public:
    // Encodes a tree to a single string.
    /* 对查找二叉树进行前序遍历，将遍历到的结果按顺序插入能得到相同的查找二叉树 */
    string serialize(TreeNode* root) {
        string res;
        bst_preorder(root, res);
        return res;
    }
    void bst_preorder(TreeNode* root, string &res) {
        if (root == NULL) {
            return;
        }
        int val = root->val;
        /* 前序遍历，注意把字符串反序，取值反算得到val更简单， 用#分割数据 */
        string tmp;
        while (val != 0) {
            tmp += val % 10 + '0';
            val /= 10;
        }
        for (int i = tmp.size() - 1; i >= 0; i--) {
            res += tmp[i];
        }
        res += '#'; 
        bst_preorder(root->left, res);
        bst_preorder(root->right, res);        
    }
    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if (data.size() == 0) {
            return NULL;
        }
        vector  node_vec;
        int val = 0;
        for (int i = 0; i < data.size(); i++) {
            if (data[i] == '#') {
                node_vec.push_back(new TreeNode(val));
                val = 0;
            } else {
                val = val * 10 + data[i] - '0';
            }
        }
        for (int i = 1; i < node_vec.size(); i++) {
            bst_insert(node_vec[0], node_vec[i]);
        }
        return node_vec[0];
    }
     void bst_insert(TreeNode* root, TreeNode* node) {
        if (node->val < root->val) {
            if (root->left == NULL) {
                root->left = node;
            } else {
                bst_insert(root->left, node);
            }
         } else {
            if (root->right == NULL) {
                root->right = node;
            } else {
                bst_insert(root->right, node);
            }
         }
     }

逆序数：https://leetcode-cn.com/problems/count-of-smaller-numbers-after-self/submissions/

给定一个整数数组 nums，按要求返回一个新数组 counts。数组 counts 有该性质： counts[i] 的值是  nums[i] 右侧小于 nums[i] 的元素的数量。
示例:
输入: [5,2,6,1]
输出: [2,1,1,0] 

    struct BstNode {
        int val;
        int count; //左子数中节点个数
        BstNode *left;
        BstNode *right;
        BstNode(int x) : val(x), left(NULL), right(NULL), count(0) {}
    };
    vector countSmaller(vector& nums) {
        /* 利用查找二叉树数据结构，逆序插入数组nums[i], 插入过程生成节点的count[i]  
            每个节点加入一个count来记录其左子树节点的个数，插入过程如果插入左子树就更新count，
            如果插入右子树，count[i] += node->count + 1(当前节点左子树数量+1); */
        vector  count;
        vector  res;
        if (nums.size() == 0) {
            return res;
        }
        BstNode *root = new BstNode(nums[nums.size() - 1]);
        count.push_back(0);
        for (int i = nums.size() - 2; i >= 0; i--) {
            int small_count = 0;
            bst_insert(root, new BstNode(nums[i]), small_count);
            count.push_back(small_count);
        }
        for (int i = count.size() - 1; i >= 0; i--) {
            res.push_back(count[i]);
        }
        return res;    
    }
private:
     void bst_insert(BstNode* root, BstNode* node, int &small_count) {
        if (node->val <= root->val) {
            root->count++;//往左子树插入，更新count
            if (root->left == NULL) {
                root->left = node;
            } else {
                bst_insert(root->left, node, small_count);
            }
         } else {
            small_count += root->count + 1;//往右子树插入，更新统计small_count
            if (root->right == NULL) {
                root->right = node;
            } else {
                bst_insert(root->right, node, small_count);
            }
         }
     }