第8周 数据结构-树

• 在二叉查找树中寻找两个节点，使它们的和为一个给定值653. Two Sum IV - Input is a BST(Easy)
• 在二叉查找树中查找两个节点之差的最小绝对值530. Minimum Absolute Difference in BST(Easy)
• 寻找二叉查找树中出现次数最多的值501. Find Mode in Binary Search Tree(Easy)
• 实现一个 Trie208. Implement Trie (Prefix Tree)
• 实现一个 Trie，用来求前缀和677. Map Sum Pairs(Medium)

在二叉查找树中寻找两个节点，使它们的和为一个给定值

class Solution {
public:
    vector<int> nums;
    void inorder(TreeNode* node){
        if(node == NULL)
            return ;
        inorder(node->left);
        nums.push_back(node->val);
        inorder(node->right);
    }
    bool findTarget(TreeNode* root, int k) {
        /*
        思路：中序遍历将二叉搜索树存到数组中，然后使用双指针法搜索是否存在和为k的pair
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        inorder(root);
        int i = 0, j = nums.size() - 1;
        while(i < j){
            if(nums[i] + nums[j] < k)
                i += 1;
            else if(nums[i] + nums[j] > k)
                j -= 1;
            else
                return true;
        }
        return false;
    }
};

在二叉查找树中查找两个节点之差的最小绝对值

class Solution {
public:
    vector<int> nums;
    void inorder(TreeNode* node){
        if(node == NULL)
            return ;
        inorder(node->left);
        nums.push_back(node->val);
        inorder(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        /*
        思路：中序遍历然后计算相邻数的差值的最小值
        */
        inorder(root);
        int ans = 10e6;
        for(int i = 0;i < nums.size()-1; i++)
            if(nums[i+1] - nums[i] < ans)
                ans = nums[i+1] - nums[i];
        return ans;
    }
};

寻找二叉查找树中出现次数最多的值

class Solution {
public:
    vector<int> nums;
    void inorder(TreeNode* node){
        if(node == NULL)
            return ;
        inorder(node->left);
        nums.push_back(node->val);
        inorder(node->right);
    }
    vector<int> findMode(TreeNode* root) {
        /*
        思路：中序遍历得到数组然后再统计
        时间复杂度：O(n)
        空间复杂度：O(n)
        */
        inorder(root);
        
        map<int,int> counter;
        for(int i = 0;i < nums.size(); i++)
            counter[nums[i]] += 1;
        vector<int> ans;
        int max_times = 0;
        map<int, int>::iterator iter;
        for(iter = counter.begin(); iter != counter.end(); iter++) {
            if(iter->second > max_times){
                ans.clear();
                ans.push_back(iter->first);
                max_times = iter->second;
            }
            else if(iter->second == max_times){
                ans.push_back(iter->first);
            }
        }
        return ans;
    }    
};

Trie

实现一个 Trie

主要难点在于节点的构造，由于tri树是一棵多叉树所以自然会想到使用map，key自然是char，但是value如何表示，value希望存的是由key找到的下一层的节点，所以自然想到value应当设置为节点的指针类型。

typedef struct node_{
    map<char, node_*> mp;
}Node;

class Trie {
public:
    Node* root;
    /** Initialize your data structure here. */
    Trie() {
        root = new Node();
    }
    
    /** Inserts a word into the trie. */
    void insert(string word) {
        Node* node = root;
        for(int i = 0;i < word.size(); i++){
            if((node->mp).find(word[i]) == (node->mp).end())
                node->mp[word[i]] = new Node();
            node = node->mp[word[i]];
        }
        (node->mp)['#'] = new Node();
    }
    
    /** Returns if the word is in the trie. */
    bool search(string word) {
        Node* node = root;;
        for(int i = 0;i < word.size(); i++){
            if((node->mp).find(word[i]) == (node->mp).end())
                return false;
            node = node->mp[word[i]];
        }
        return (node->mp).find('#') != (node->mp).end();
    }
    
    /** Returns if there is any word in the trie that starts with the given prefix. */
    bool startsWith(string prefix) {
        Node* node = root;
        for(int i = 0;i < prefix.size(); i++){
            if((node->mp).find(prefix[i]) == (node->mp).end())
                return false;
            node = node->mp[prefix[i]];
        }
        return true;
    }
};

实现一个 Trie，用来求前缀和

和tri树类似，区别在于用来求前缀和的tri树需要存值所以在节点定义部分增加一个成员变量存值

typedef struct node_{
    map<char, node_*> mp;
    int value;
    node_(int v){
        value = v;
    }
}Node;

class MapSum {
public:
    Node* root;
    /** Initialize your data structure here. */
    MapSum() {
        root = new Node(0);
    }
    
    void insert(string key, int val) {
        Node* node = root;
        for(int i = 0;i < key.size(); i++){
            if((node->mp).find(key[i]) == (node->mp).end())
                node->mp[key[i]] = new Node(0);
            node = node->mp[key[i]];
        }
        (node->mp)['#'] = new Node(val);
    }
    
    int sum(string prefix) {
        Node* node = root;
        for(int i = 0;i < prefix.size(); i++){
            if((node->mp).find(prefix[i]) == (node->mp).end())
                return 0;
            node = node->mp[prefix[i]];
        }
        queue<Node*> q;
        q.push(node);
        int ans = 0;
        
        while(!q.empty()){
            Node* node = q.front();
            q.pop();
            
            for(auto it: node->mp){
                if(it.first == '#')
                    ans += it.second->value;
                else
                    q.push(it.second);
            }
        }
        
        return ans;
        
    }
};