二叉树题目总结(一)

1. 线索化二叉树

一颗有n个节点的二叉树，必然有n + 1个空指针，可以利用这些空指针记录二叉树的某种遍历序的前驱和(或)后继信息

下面给出中序线索化二叉树的代码：

#include <iostream>

struct ThreadTreeNode {
    int val;
    bool ltag; /* 0 for link, 1 for thread */
    bool rtag;
    ThreadTreeNode *left;
    ThreadTreeNode *right;
    ThreadTreeNode(int v = -1) : val(v), ltag(0), rtag(0), left(NULL), right(NULL) { }
};

class Solution {
public:
    void *inorderThreadMirror(ThreadTreeNode *root) {
        if(!root) return NULL;
        ThreadTreeNode *prev = NULL;
        ThreadTreeNode *curr = root;
        while(curr) {
            if(!curr->left) {
                curr->ltag = 1; /* no left child threaded it */
                curr->left = prev; /* if curr is the first node in inorder, its prev is NULL */
                prev = curr;
                curr = curr->right;
            }
            else {
                ThreadTreeNode *temp = curr->left;
                while(temp->right && temp->right != curr) temp = temp->right;
                if(!temp->right) { /* has not been visited */
                    temp->rtag = 1;
                    temp->right = curr;
                    curr = curr->left;
                }
                else { /* has been visited */
                    prev = curr;
                    curr = curr->right;
                }
            }
        }
    }
    void inorderTraversal(ThreadTreeNode *root) {
        while(root && root->ltag != 1) root = root->left; /* find the first node in inorder */
        while(root) {
            std::cout << root->val << "  ";
            if(!root->right) break; /* right node in NULL, says that its the last node */
            if(root->rtag == 1) /* thread */
                root = root->right;
            else { /* link */
                root = root->right;
                while(root && root->ltag != 1) root = root->left;
            }
        }
        std::cout << std::endl;
    }
};

int main() {
    ThreadTreeNode *root = new ThreadTreeNode(0);
    root->left = new ThreadTreeNode(1);
    root->right = new ThreadTreeNode(2);
    root->left->left = new ThreadTreeNode(3);
    root->left->right = new ThreadTreeNode(4);
    root->left->right->left = new ThreadTreeNode(5);
    root->left->right->right = new ThreadTreeNode(6);
    Solution s;
    s.inorderThreadMirror(root);
    s.inorderTraversal(root);
    return 0;
}

2. 求二叉树节点间的最大距离

对任一个节点，计算该节点到左边的最大距离+到右边的最大距离，保存起来，但只返回到左边或到右边的最大距离

#include <iostream>

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int v = -1) : val(v), left(NULL), right(NULL) { } 
};

class Solution {
public:
    Solution() {r_max = 0;} 

    int maxDistanceDFS(TreeNode *root) {
        dfs(root);
        return r_max;
    }   
    int maxDistance(TreeNode *root) {
        if(!root) return 0;
        int a = maxDep(root->left) + maxDep(root->right);
        int b = maxDistance(root->left);
        int c = maxDistance(root->right);
        return std::max(std::max(a, b), c);    
    }   
    int r_max;
private:
    int maxDep(TreeNode *root) {
        if(!root) return 0;
        return std::max(maxDep(root->left), maxDep(root->right)) + 1;
    }   
    int dfs(TreeNode *root) {
        if(!root) return 0;
        int l = dfs(root->left);
        int r = dfs(root->right);
        r_max = std::max(r_max, l + r); 
        return l > r ? l + 1 : r + 1;
    }   
};

int main() {
    TreeNode *root = new TreeNode(1);
    root->right = new TreeNode(3);
    root->right->left = new TreeNode(4);
    root->right->right = new TreeNode(5);
    root->right->left->left = new TreeNode(6);
    root->right->left->right = new TreeNode(7);
    root->right->right->right = new TreeNode(8);
    std::cout << (new Solution)->maxDistanceDFS(root) << std::endl;
    std::cout << (new Solution)->maxDistance(root) << std::endl;
    return 0;
}

3. 最近公共祖先

#include <iostream>

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int v = -1) : val(v), left(NULL), right(NULL) { }
};

class Solution {
public:
    TreeNode *commonForefather(TreeNode *root, TreeNode *childa, TreeNode *childb) {
        if(isHere(root->left, childa) && isHere(root->left, childb)) {
            if(root->left == childa || root->left == childb)
                return root;
            return commonForefather(root->left, childa, childb);
        }
        else if(isHere(root->right, childa) && isHere(root->right, childb)) {
            if(root->right == childa || root->right == childb)
                return root;
            return commonForefather(root->right, childa, childb);
        }
        else
            return root;
    }
private:
    bool isHere(TreeNode *root, TreeNode *child) {
        if(root == child)
            return true;
        if(root == NULL)
            return false;
        return isHere(root->left, child) || isHere(root->right, child);
    }
};

int main() {
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->right->left = new TreeNode(4);
    root->right->left->left = new TreeNode(5);
    root->right->left->right = new TreeNode(6);
    std::cout << (new Solution)->commonForefather(root, root->right->left->left, root->right->left)->val << std::endl;
    return 0;
}

4. 二叉树的高度和宽度

高度定义为二叉树的最大深度

宽度定义为高度相同节点数目的最大值

#include <iostream>
#include <queue>

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int v = -1) : val(v), left(NULL), right(NULL) { }
};

class Solution {
public:
    int biTreeDep(TreeNode *root) {
        if(!root) return 0;
        return std::max(biTreeDep(root->left), biTreeDep(root->right)) + 1;
    }
    int biTreeWidth(TreeNode *root) {
        if(!root) return 0;
        std::queue<TreeNode *> que;
        int maxWidth = 0;
        int curWidth = 0;
        que.push(root);
        que.push(NULL);
        while(!que.empty()) {
            while(que.front()) {
                TreeNode *curr = que.front();
                que.pop();
                curWidth++;
                if(curr->left) que.push(curr->left);
                if(curr->right) que.push(curr->right);
            }
            maxWidth = std::max(maxWidth, curWidth);
            curWidth = 0;
            que.pop();
            if(que.empty()) break;
            que.push(NULL);
        }
        return maxWidth;
    }
};

int main() {
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->right->right = new TreeNode(4);
    root->right->right->left = new TreeNode(5);
    root->right->right->left->right = new TreeNode(6);
    Solution s;
    std::cout << s.biTreeDep(root) << std::endl;
    std::cout << s.biTreeWidth(root) << std::endl;
    return 0;
}

5. Huffman编码

#include <iostream>
#include <vector>
#include <queue>
#include <map>
using namespace std;

typedef unsigned int uint;
struct HuffTreeNode {
    uint weight;
    HuffTreeNode *lchild;
    HuffTreeNode *rchild;
    HuffTreeNode *parent;
    HuffTreeNode(uint w = 0) : weight(w), lchild(NULL), rchild(NULL), parent(NULL) { }
};
struct Cmp {
    bool operator() (const HuffTreeNode *a, const HuffTreeNode *b) {
        return a->weight > b->weight;
    }
};
class Solution {
public:
    HuffTreeNode* createHuffmanCodingTree(const vector<uint> &weight) {
        priority_queue<HuffTreeNode *, vector<HuffTreeNode *>, Cmp > pri_que;
        HuffTreeNode *prev = NULL;
        HuffTreeNode *curr = NULL;
        for(int i = 0; i < weight.size(); i++)
            pri_que.push(new HuffTreeNode(weight[i]));
        while(!pri_que.empty()) {
            prev = pri_que.top(), pri_que.pop();
            if(pri_que.empty()) break;
            curr = pri_que.top(), pri_que.pop();
            HuffTreeNode *parent = new HuffTreeNode(prev->weight + curr->weight);
            parent->lchild = prev->lchild ? curr : prev;
            parent->rchild = prev->lchild ? prev : curr;
            prev->parent = curr->parent = parent;
            pri_que.push(parent);
        }
        this->root = prev;
        return prev; 
    }
    void createHuffmanEncodeMap() {
        string bits;
        HuffTreeNode *curr = this->root;
        while(curr) {
            if(!curr->lchild) {
                encode_map[curr->weight] = bits;
                curr = curr->rchild;
            }
            else {
                HuffTreeNode *temp = curr->lchild;
                int backlevel = 1;
                while(temp->rchild && temp->rchild != curr) temp = temp->rchild, backlevel++;
                if(!temp->rchild) {
                    /* visit curr */
                    bits += "0";
                    temp->rchild = curr;
                    curr = curr->lchild;
                }
                else {
                    /* trace back to "root" node */
                    bits = bits.substr(0, bits.size() - backlevel); 
                    bits += "1";
                    temp->rchild = NULL;
                    curr = curr->rchild;
                }
            }
        }
    }
private:
    map<uint, string> encode_map;
    map<string, uint> decode_map;
    HuffTreeNode *root;
};

int main(int argc, char **argv) {
    vector<uint> v_ui;
    v_ui.push_back(5);
    v_ui.push_back(29);
    v_ui.push_back(7);
    v_ui.push_back(8);
    v_ui.push_back(14);
    v_ui.push_back(23);
    v_ui.push_back(3);
    v_ui.push_back(11);
    Solution s;
    s.createHuffmanCodingTree(v_ui);
    s.createHuffmanEncodeMap();
    for(int i = 0; i < v_ui.size(); i++)
        cout << v_ui[i] << " : " << s.encode_map[v_ui[i]] << endl;
    return 0;
}

由于本人水平有限，文中不当和错误之处难以避免，欢迎大家批评指正，愿共同进步！！！