题目一：矩阵转置
AA
矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
示例 1：
输入：[[1,2,3],[4,5,6],[7,8,9]] 输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：
输入：[[1,2,3],[4,5,6]] 输出：[[1,4],[2,5],[3,6]]
思路：比较简单，但要注意对矩阵的初始化，如果不初始化会报错--》reference binding to null pointer of type ‘struct value_type‘
class Solution { public: vector<vector<int>> transpose(vector<vector<int>>& A) { if(A.size()==0){ return A ; } vector<vector<int>> Ar(A[0].size()); for (int i = 0; i < Ar.size(); i++) Ar[i].resize(A.size()); for (int i = 0; i<A[0].size(); i++) { for (int j = 0; j<A.size(); j++) { Ar[i][j] = A[j][i]; } } return Ar ; } };
题目二：
具有所有最深结点的最小子树
root深度是它到根的最短距离。
如果结点具有最大深度，则该结点是最深的。
返回具有最大深度的结点，以该结点为根的子树中包含所有最深的结点。
输入：[3,5,1,6,2,0,8,null,null,7,4] 输出：[2,7,4] 解释：
我们返回值为 2 的结点，在图中用黄色标记。 在图中用蓝色标记的是树的最深的结点。 输入 "[3, 5, 1, 6, 2, 0, 8, null, null, 7, 4]" 是对给定的树的序列化表述。 输出 "[2, 7, 4]" 是对根结点的值为 2 的子树的序列化表述。 输入和输出都具有 TreeNode 类型。
思路：这个题要注意的是，不是返回一个最深的节点，而是返回一个包含所有最深的子树，也就是如果是一颗满二叉树，那么就返回跟节点。然后就只要判断左右两个孩子哪个节点更深，就返回哪个，如果一样深就返回当前根节点
/** * 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: TreeNode* find(TreeNode* root){ if(root==NULL){ return NULL ; } int depofL = getLen(root->left) ; int depofR = getLen(root->right) ; if(depofL==depofR){ return root ; } if(depofL>depofR){ return find(root->left) ; }else{ return find(root->right) ; } } int getLen(TreeNode* root){ if(root==NULL){ return 0 ; } return 1+max(getLen(root->left),getLen(root->right)) ; } TreeNode* subtreeWithAllDeepest(TreeNode* root) { TreeNode* ans = find(root) ; return ans ; } };
题目三：重构二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路：这个题就是对照两种序列把序列分段然后递归，无奈vector版还要记录每一次递归时两种序列的开始和结束位置，还是字符串直接取子串比较方便。vector并不知道怎么取子集，而且就算取了也很占空间，难受，直接贴一下网上的代码
struct TreeNode * subTree(vector<int> pre, int preStart, int preEnd, vector<int> in, int inStart, int inEnd) { struct TreeNode * rootTree = (struct TreeNode *) malloc (sizeof(struct TreeNode)); rootTree -> val = pre[preStart]; rootTree -> left = NULL; rootTree -> right = NULL; if (preStart == preEnd && inStart == inEnd && pre[preStart] == in[inStart]) return rootTree; int rootIndex = inStart; while (in[rootIndex] != pre[preStart]) rootIndex ++; int newLength = rootIndex - inStart; if (newLength > 0) rootTree -> left = subTree(pre, preStart + 1, preStart + newLength, in, inStart, rootIndex - 1); if (inEnd - rootIndex > 0) rootTree -> right = subTree(pre, preStart + newLength + 1, preEnd, in, rootIndex + 1, inEnd); return rootTree; } struct TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in) { int preLength = pre.size(); int inLength = pre.size(); if (preLength == 0 || inLength == 0) return NULL; return subTree(pre, 0, preLength - 1, in, 0, inLength - 1); }
原文：https://www.cnblogs.com/maskmtj/p/9281520.html