leetcode 刷题日志 2018-3-28
树：
404. 左叶子之和
求所有左叶子结点之和 1. 递归法 分析：递归法遍历结点，找左叶子结点 空指针判断 有左子节点？是叶子结点？是的话更新value的值 int sumOfLeftLeaves(TreeNode* root) { if(!root) return 0; // NULL int value = 0; if(root->left){ //左子节点 if(!root->left->left && !root->left->right) //是不是叶子结点？ value = root->left->val ; } return value + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right); }
2.非递归法遍历寻找所有左叶子结点 int sumOfLeftLeaves(TreeNode* root) { if(!root) return 0; //注意一定要处理空指针 int res = 0; queue<TreeNode*> q; q.push(root); while(!q.empty()){ root = q.front(); q.pop(); if(root->left){ //左子节点 q.push(root->left); if(!root->left->left && !root->left->right){ //是否为叶子结点 res += root->left->val; } } if(root->right){ q.push(root->right); } } return res; }
671. Second Minimum Node In a Binary Tree
题意：求二叉树第二小值，没有返回-1 分析：用set存所有节点，最终容量大于2，代表存在第二小值，输出*(++set.begin()) ``` int findSecondMinimumValue(TreeNode* root) { if(!root) return -1; int res = -1; queue<TreeNode* > q; q.push(root); set<int> s; while (!q.empty()) { root = q.front(); s.insert(root->val); q.pop(); if (root->left) { q.push(root->left); } if (root->right) { q.push(root->right); } } if(s.size() < 2) res = -1; else res = *(++s.begin()); return res; }
102. 二叉树的层次遍历
二叉树层次遍历且每层输出 算法记忆：一层一循环 ``` vector<vector<int>> levelOrder(TreeNode* root) { vector<vector<int> > res; vector<int> tmp; if(!root) return res; queue<TreeNode*> q; q.push(root); int currentLevelTotalNum = 0; while(!q.empty()) { tmp.clear(); currentLevelTotalNum = q.size(); while(currentLevelTotalNum--){ //一层一循环 root = q.front(); tmp.push_back(root->val); q.pop(); if(root->left){ q.push(root->left); } if(root->right){ q.push(root->right); } } res.push_back(tmp); } return res; } ```
107. 二叉树的层次遍历 II
分析：在正序层析遍历基础上，用栈临时存一下
vector<vector<int>> levelOrderBottom(TreeNode* root) { vector<vector<int> > res; vector<int> tmp; stack<vector<int> >tmps; if(!root) return res; queue<TreeNode*> q; q.push(root); int currentLevelTotalNum = 0; while(!q.empty()) { tmp.clear(); currentLevelTotalNum = q.size(); while(currentLevelTotalNum--){ //一层一循环 root = q.front(); tmp.push_back(root->val); q.pop(); if(root->left){ q.push(root->left); } if(root->right){ q.push(root->right); } } tmps.push(tmp); } while(!tmps.empty()){ res.push_back(tmps.top()); tmps.pop(); } return res; }
637. 二叉树的层平均值
题意：求二叉树每层平均值(double)所组成的数组 分析：每层求和取平均值 ``` vector<double> averageOfLevels(TreeNode* root) { vector<double> res; if(!root) return res; queue<TreeNode* > q; q.push(root); int currentLevelTotalNum = 0, n = 0; double tmpd; while(!q.empty()){ currentLevelTotalNum = q.size(); n = currentLevelTotalNum; tmpd = 0; while(currentLevelTotalNum--){ //此层所有节点 root = q.front(); tmpd +=root->val; q.pop(); if(root->left){ q.push(root->left); } if(root->right) { q.push(root->right); } } tmpd /= n; res.push_back(tmpd); } return res; } ```
101. 对称二叉树
关键点在于递归比较。
题意：给定一个二叉树，检查它是否是它自己的镜像（即，围绕它的中心对称）。 分析：一个结点左子节点l，与右子节点r比较，递归的判断整棵树，l的左与r的右 且l的右跟r的左比较 抽取出递归模型如下 ``` bool is(TreeNode* root1, TreeNode* root2){ if(!root1 && !root2) return true; if(!root1) return false; if(!root2) return false; if(root1->val != root2->val){ return false; } return is(root1->left,root2->right) && is(root1->right,root2->left); } bool isSymmetric(TreeNode* root) { if(!root) return true; return is(root->left,root->right); } ```
111. 二叉树的最小深度
题意：二叉树最小深度（从根节点到叶子结点的结点个数，包含两端） 分析：递归， 终结条件是 1. root ==NULL 0 2. 叶子结点 1 分别计算左子树、右子树的长度 取最小值，因为加上本结点所以最终返回值+1 ``` int minDepth(TreeNode* root) { if(!root) return 0; if(!root->left && !root->right) return 1; int left,right; if(root->left) left = minDepth(root->left); else left = INT_MAX; if(root->right) right = minDepth(root->right); else right = INT_MAX; return min(left,right) + 1; } ```
104. 二叉树的最大深度
题意：最大二叉树深度 分析：递归法 1.终结条件： 1. NULL 0 2. 叶子结点 1 2. 分别计算左右子树长度 3. 返回max(left,right)+1 加1是因为加上本结点 ``` int maxDepth(TreeNode* root) { if(!root) return 0; if(!root->left && !root->right) return 1; int left, right; if(root->left) left = maxDepth(root->left); else left = INT_MIN; if(root->right) right = maxDepth(root->right); else right = INT_MIN; return max(left,right) + 1; } ```
110. 平衡二叉树
题意：判断是否为平衡二叉树 分析： 本题是递归数深度遍历的一种应用。按照题目的意思，对于一个节点分别算出每个节点的左、右子树的深度，如果左、右子树深度差大于1，则可以该树非平衡。
那么递归每一个节点，一旦发现某一节点非平衡，就返回false，如果每一节点都平衡，则返回true： ``` //获取树的深度 int getDepth(TreeNode* root){ if(!root) return 0; return max(getDepth(root->left),getDepth(root->right)) + 1; } //递归判断每个结点的子树是否满足长度只差不大于1 bool isBalanced(TreeNode* root) { if(!root) return true; if(abs(getDepth(root->left) - getDepth(root->right)) > 1){ return false; } return isBalanced(root->left) && isBalanced(root->right); } ```
144. 二叉树的前序遍历 +1 2
题目：二叉树，前序遍历，迭代法
分析：DFS，用到栈，一直沿着左指针将沿路节点压入栈内，当到尽头，弹出top结点，将其右子树压入，右子树同样是先沿着左指针压到尽头后，向右展
记忆：深搜栈右展
``` vector<int> res; vector<int> preorderTraversal(TreeNode* root) { //递归 if(root){ res.push_back(root->val); preorderTraversal(root->left); preorderTraversal(root->right); } return res; } vector<int> preorderTraversal(TreeNode* root) { //迭代 vector<int> res; if(!root) return res; stack<TreeNode*> s; while (!s.empty() || root != NULL) { if (root) { //至最左 res.push_back(root->val); s.push(root); root = root->left; } else { //左到尽头，往右走 root = s.top(); s.pop(); root = root->right; } } return res; } ```
94. 中序遍历二叉树 1+2
题意： 二叉树中序遍历，迭代法
分析： DFS，利用栈，沿着左指针将一直到最左端的沿路所有节点依次压入栈中，每到到最左端向右展一下
记忆：深搜栈右展
``` vector<int> inorderTraversal(TreeNode* root) { stack< TreeNode* > s; TreeNode * p = root; vector<int> tmp; while(!s.empty() || p!=NULL){ while(p){ //到最左端 s.push(p); p=p->left; } if(!s.empty()){ //右展一次 p=s.top(); tmp.push_back(p->val); s.pop(); p=p->right; } } return tmp; } ```
145. 二叉树的后序遍历 1 2 + 迭代法
分析：同样用到栈
记忆：+21入栈，处理两情况
//递归法 ``` vector<int> res; vector<int> postorderTraversal(TreeNode* root) { if(root){ postorderTraversal(root->left); postorderTraversal(root->right); res.push_back(root->val); } return res; } ``` //迭代法 ``` vector<int> postorderTraversal(TreeNode* root) { vector<int> res; if(!root) return res; stack<TreeNode* > s; TreeNode *cur = root, *pre = NULL; s.push(cur); // 栈中的顺序是后序遍历的反序，先压入根，再压入右结点，左结点 while (!s.empty()) { cur = s.top(); if((!cur->left && !cur->right) || (pre && (cur->left == pre || cur->right == pre))) //叶子结点直接处理 || 刚刚处理完左右结点 { res.push_back(cur->val); pre = cur; s.pop(); } else{ if(cur->right){ s.push(cur->right); } if (cur->left) s.push(cur->left); } } return res; } ```
617. 合并二叉树
/* 题意：合并两棵二叉树，对应结点相加，否则补上 分析：递归实现 根节点都为空，return NULL 根节点都不为空，求和 根节点有一个空，补上 进一步分析左右子树 前三步就是抽取出来的子过程 */ ``` TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) { if(!t1 && !t2) return NULL; if (t1 && t2) { t1->val += t2->val; t2->val = t1->val; } else if (t1) { t2 = new TreeNode(t1->val); } else if (t2) { t1 = new TreeNode(t2->val); } t1->left = mergeTrees(t1->left,t2->left); t1->right = mergeTrees(t1->right,t2->right); return t1; } ```
114. 二叉树转换链表
题意：二叉树转换链表；将所有结点编程右指针连接 分析：将前序遍历序列，顺序串联 ``` //迭代版，前序遍历 vector<TreeNode*> preOrder2(TreeNode* root) { vector<TreeNode*> res; if(!root) return res; stack<TreeNode*> s; TreeNode* p = root; while(!s.empty() || p) { while(p){ //一直往左 res.push_back(p); s.push(p); p = p->left; } if(!s.empty()){ //右展 p = s.top(); s.pop(); p = p->right; } } return res; } // 注意只需保留头指针，指针传递，传递方保留着头指针，他顺着访问就是了 void flatten(TreeNode* root) { if(!root) return ; //前序遍历结果 vector<TreeNode*> preOrderV = preOrder2(root); int len = preOrderV.size(); root->left = NULL; root->right = NULL; //链表形成 for(int i=0;i<len;i++) { root->right = preOrderV[i]; root = preOrderV[i]; root->left = NULL; root->right =NULL; } } ```
112. 路径总和
/* 题意：路径总和，给一棵二叉树和一个整数sum，问是否存在从根节点到叶节点的路径，求和等于sum 分析：递归，和递减 */ ``` bool hasPathSum(TreeNode* root, int sum) { if(!root) return false; if(root->val == sum){ //恰好有叶节点满足 if(!root->left && !root->right){ return true; } } return hasPathSum(root->left,sum-root->val) || hasPathSum(root->right,sum-root->val); } ```
113. 路径总和 II
题意：找出一棵二叉树里，路径（根结点到叶结点）上结点之和等于sum的所有路径
分析：经典递归回溯问题，搜集路径上所有节点时，注意遇到结点push,用完节点pop
经典递归回溯 ``` vector<vector<int> >result; vector<int> path; // 经典递归回溯问题 void findPath(TreeNode* root, int sum) { if(!root) return ; if(root->val == sum && !root->left && !root->right ) { //find a path equal sum && It's a leaf node path.push_back(root->val); result.push_back(path); // find a path path.pop_back(); //!! return ; } path.push_back(root->val); // 经过节点压入 findPath(root->left, sum - root->val); findPath(root->right, sum - root->val); path.pop_back(); // 对与此节点的左右子树都已经处理完，弹出此节点 ! } vector<vector<int>> pathSum(TreeNode* root, int sum) { vector<vector<int>> res; if(!root) return res; findPath(root, sum); return result; } ```
257. 二叉树的所有路径
/* 题意：输出二叉树所有路径 分析：经典递归回溯法 */ ``` vector<vector<int> >allPath; //所有路径 vector<int> aPath; //单条路径 // 经典递归回溯法求二叉树所有路径 void findPath(TreeNode* root) { if(!root) return ; if(!root->left && !root->right) { //leaf node aPath.push_back(root->val); allPath.push_back(aPath); // a path aPath.pop_back(); return ; } aPath.push_back(root->val); findPath(root->left); findPath(root->right); aPath.pop_back(); } vector<string> binaryTreePaths(TreeNode* root) { vector<string> res; if(!root) return res; findPath(root); int len = allPath.size(); string tmpS = ""; for (int i=0; i<len; i++) { tmpS = std::to_string(allPath[i][0]); for (int j=1; j<allPath[i].size(); j++) { //形成路径字符串 tmpS += ("->" + std::to_string(allPath[i][j])); } res.push_back(tmpS); } return res; } ```
