二叉树题目-leetcode

101 Symmetric Tree

给定一颗二叉树，检查是否镜像对称（围绕中心对称）

分析：递归，从根节点开始，判断左节点的左子树与右节点的右子树，左节点的右子树与右节点的左子树是否相等即可！

class Solution {public:    bool judge(TreeNode* left, TreeNode* right){        if ((!left) && (!right)) return true;        if ((!left) || (!right)) return false;        if (left->val != right->val) return false;        return judge(left->right, right->left)&&judge(left->left, right->right);    }    bool isSymmetric(TreeNode* root) {        if (!root) return true;        return judge(root->left, root->right);    }};

非递归的写法：中间的时候不能return true，应该continue

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    bool isSymmetric(TreeNode* root) {        if (!root) return true;        queue <TreeNode*> que;        que.push(root->left);        que.push(root->right);        TreeNode* leftNode;        TreeNode* rightNode;        while(!que.empty()){            leftNode = que.front();            que.pop();            rightNode = que.front();            que.pop();            if ((!leftNode) && (!rightNode)) continue;                //return true;是不对的            if ((!leftNode) || (!rightNode)) return false;            if (leftNode->val != rightNode->val) return false;            que.push(leftNode->right);            que.push(rightNode->left);            que.push(leftNode->left);            que.push(rightNode->right);    }        return true;}};

116 Populating Next Right Pointers in Each Node I

分析：层序遍历的思路，注意利用next指针，使得空间复杂度控制在O(1)。

/** * Definition for binary tree with next pointer. * struct TreeLinkNode { *  int val; *  TreeLinkNode *left, *right, *next; *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} * }; */class Solution {public:    void connect(TreeLinkNode *root) {        if (root == NULL) return;        root -> next = NULL;        TreeLinkNode *curNode = root;        while (curNode) {             TreeLinkNode *node = curNode;             if (!node -> left) return;              while (node) {                 node -> left -> next = node -> right;                 if(node -> next) node -> right -> next = node -> next -> left;                 node = node -> next;             }             curNode = curNode -> left;        }    }};

117 Populating Next Right Pointers in Each Node II

思路：层序遍历,O(1)空间复杂度和O(n)时间复杂度

/** * Definition for binary tree with next pointer. * struct TreeLinkNode { *  int val; *  TreeLinkNode *left, *right, *next; *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} * }; */class Solution {public:    void connect(TreeLinkNode *root) {        // current level node        TreeLinkNode *curNode = root;        while (curNode) {             //the first node of next level                        TreeLinkNode *firstNode = new TreeLinkNode(0);               TreeLinkNode *nextNode = firstNode;             //level-order traversal              while(curNode){                   if (curNode -> left) {                 nextNode->next = curNode->left;                 nextNode = nextNode->next;                }                if (curNode -> right) {                 nextNode->next = curNode->right;                 nextNode = nextNode->next;                }                  curNode = curNode->next;              }             //jump to the next level             curNode = firstNode->next;             delete firstNode;    }    }};

类似的思路：

public class Solution {    //based on level order traversal    public void connect(TreeLinkNode root) {        TreeLinkNode head = null; //head of the next level        TreeLinkNode prev = null; //the leading node on the next level        TreeLinkNode cur = root;  //current node of current level        while (cur != null) {            while (cur != null) { //iterate on the current level                //left child                if (cur.left != null) {                    if (prev != null) {                        prev.next = cur.left;                    } else {                        head = cur.left;                    }                    prev = cur.left;                }                //right child                if (cur.right != null) {                    if (prev != null) {                        prev.next = cur.right;                    } else {                        head = cur.right;                    }                    prev = cur.right;                }                //move to next node                cur = cur.next;            }            //move to next level            cur = head;            head = null;            prev = null;        }    }}

129. Sum Root to Leaf Numbers

分析：深度优先遍历，累计当前结点的值。

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    int sumNumbers(TreeNode* root) {        return (root, 0);    }    int df(TreeNode* root, int sum) {        if (!root) return 0;        if (!root->left&&!root->right) return sum*10+root->val;        return df(root->left, sum*10+root->val) + df(root->right, sum*10+root->val);    }};

199. Binary Tree Right Side View

深度遍历或者广度遍历
广度优先遍历

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    vector<int> rightSideView(TreeNode* root) {    vector<int> res;    if (!root) return res;    queue <TreeNode*> nodes;    nodes.push(root);    while (!nodes.empty()) {        res.push_back(nodes.front()->val);        int len = nodes.size();        for (int i = 0; i < len; ++i){            TreeNode* cur = nodes.front();            if (cur->right) nodes.push(cur->right);            if (cur->left) nodes.push(cur->left);              nodes.pop();        }    }    return res;    }};

前序遍历，比较简洁

class Solution {public:    void dfs(TreeNode* root, int lv, vector<int> &res){        if(!root)   return;        if(lv>=res.size()) res.push_back(root->val);        dfs(root->right,lv+1,res);        dfs(root->left,lv+1,res);    }    vector<int> rightSideView(TreeNode* root) {        vector<int> res;        dfs(root, 0, res);        return res;    }};

236. Lowest Common Ancestor of a Binary Tree

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
求任意二叉树的最小公共结点

思路并不复杂，思路就是记录从根节点达到p和q的两条路径，显然知道了两条路径之后，不相同的上一个节点就是最低公共祖先。

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public:    vector<TreeNode*> qPath;      vector<TreeNode*> pPath;     void findPath(TreeNode* node, TreeNode* p, TreeNode* q, vector<TreeNode*> & res){        if (!pPath.empty() && !qPath.empty()) return;        res.push_back(node);        if (node == p) pPath = res;        if (node == q) qPath = res;        if (node -> left) findPath(node->left, p, q, res);        if (node -> right) findPath(node->right, p, q, res);        res.pop_back(); // back_track    }    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {        if(!root || !p || !q) return NULL;          vector<TreeNode*> res;//找出两个包含这两个结点的路径          findPath(root,q,p,res);         if (pPath.empty() || qPath.empty()) return NULL;// 有一个结点没有查找到        int i = 0, j = 0;        int pLen = pPath.size(), qLen = qPath.size();        while (i < pLen && j < qLen) {            if (pPath[i] != qPath[j]) return pPath[i-1];            if (i == pLen - 1) return pPath[i];            if (j == qLen - 1) return qPath[j];            ++i, ++j;        }    }};

别人的DFS的简洁的写法，但是我质疑的一点就是，如果两个节点有一个不在这个树上的时候，这样怎么处理？

TreeNode * dfsTraverse(TreeNode * root, TreeNode * p , TreeNode * q){    if( root == p || root == q || root == NULL)        return root;    TreeNode * parent1 = dfsTraverse(root->left, p, q);    TreeNode * parent2 = dfsTraverse(root->right, p, q);    if( parent1 && parent2)        return root;    else        return parent1 ? parent1:parent2;}TreeNode * lowestCommonAncestor(TreeNode * root, TreeNode * p, TreeNode * q){    return dfsTraverse(root, p, q);}