stdleohao的博客

题目描述给定一棵二叉树，判断其是否是自身的镜像（即：是否对称）例如：下面这棵二叉树是对称的1/ 2 2/ \ / 3 4 4 3下面这棵二叉树不对称。1/ 2 2\ 3 3备注：希望你可以用递归和迭代两种方法解决这个问题思路像后序遍历一样的递归遍历，外侧节点和外侧节点比较，内侧节点和内侧节点比较/** * struct TreeNode { * int val; * struct TreeNode *left; * struc

题目描述给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历） 例如： 给定的二叉树是{3,9,20,#,#,15,7},/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param root TreeNode类 * @re

题目描述给出一棵树的前序遍历和中序遍历，请构造这颗二叉树 注意： 可以假设树中不存在重复的节点/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param preorder int整型vector * @param inorder int整型

题目描述给出一棵树的中序遍历和后序遍历，请构造这颗二叉树 注意： 保证给出的树中不存在重复的节点思路思路很容易想，但是能不能顺利写出代码来又是另外一回事。我使用了开区间后序遍历的左右子树的区分应该由中序遍历得到的左子树长度来固定，而不是由中序遍历左子树的下标。/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution

题目描述给定一个二叉树和一个值\ sum sum，请找出所有的根节点到叶子节点的节点值之和等于\ sum sum 的路径，例如：给出如下的二叉树， sum=22，返回 [ [5,4,11,2], [5,8,9] ]思路利用递归的先序遍历，每次储存遍历过的节点，并用sum去减，最后判断是否为0/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * };

题目描述给定两个字符串S和T，返回S子序列等于T的不同子序列个数有多少个？字符串的子序列是由原来的字符串删除一些字符（也可以不删除）在不改变相对位置的情况下的剩余字符（例如，"ACE"is a subsequence of"ABCDE"但是"AEC"不是）例如：S=“nowcccoder”, T = “nowccoder”返回3思路动态规划，从最小母串、最小子串开始用二维数组存储可能性class Solution {public: /** * * @

题目描述继续思考"填充每个节点指向最右节点的next指针" 这道题 如果给定的树可以是任意的二叉树呢?你之前的给出的算法还有效吗? 注意：你只能使用常量的额外内存空间/** * Definition for binary tree with next pointer. * struct TreeLinkNode { * int val; * TreeLinkNode *left, *right, *next; * TreeLinkNode(int x) : val(x), left

题目描述给出一个索引k，返回杨辉三角的第k行 例如，k=3， 返回[1,3,3,1]. 备注： 你能将你的算法优化到只使用O(k)的额外空间吗?思路只能创建一维数组，长度为：行数+1，初始化全一从第三行开始更新，并且每次从每行中间开始往前更新每个位置为前一个位置与本身的和将对称位置赋值class Solution {public: /** * * @param rowIndex int整型 * @return int整型vector

题目描述给出一个三角形，计算从三角形顶部到底部的最小路径和，每一步都可以移动到下面一行相邻的数字，例如，给出的三角形如下：[[20],[30,40],[60,50,70],[40,10,80,30]]最小的从顶部到底部的路径和是20 + 30 + 50 + 10 = 110。注意：如果你能只用O（N）的额外的空间来完成这项工作的话，就可以得到附加分，其中N是三角形中的行总数。class Solution {public: int minimumTotal(vector&lt.

题目描述给定一个无序的整数类型数组，求最长的连续元素序列的长度。 例如： 给出的数组为[1000, 4, 2000, 1, 3, 2],最长的连续元素序列为[1, 2, 3, 4]. 返回这个序列的长度：4 你需要给出时间复杂度在O（n）之内的算法思路第一反应使用哈希表，然后是想到map，但题目要求时间复杂度O(n)，map是有序的所以要用无序的，又输入是vector,所以使用同样是基于hash表的unorder_set接着只要遍历查找每个数的+1，-1的值是否存在，记录序列长度每次将序列

题目描述环形路上有n个加油站，第i个加油站的汽油量是gas[i].你有一辆车，车的油箱可以无限装汽油。从加油站i走到下一个加油站（i+1）花费的油量是cost[i]，你从一个加油站出发，刚开始的时候油箱里面没有汽油。求从哪个加油站出发可以在环形路上走一圈。返回加油站的下标，如果没有答案的话返回-1。 注意： 答案保证唯一。示例1输入复制[2,3,1],[3,1,2]返回值1class Solution {public: /** * * @param g

题目描述给定一个仅包含数字\0-9 的二叉树，每一条从根节点到叶子节点的路径都可以用一个数字表示。找出根节点到叶子节点的所有路径表示的数字之和/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param root TreeNode类 * @

题目描述给定一个数组和一个值，使用就地算法将数组中所有等于这个值的元素删除，并返回新数组的长度。元素的顺序可以更改。你不用去关心大于当前数组长度的空间里面存储的值class Solution {public: int removeElement(int A[], int n, int elem) { for(int i = 0; i < n; i++){ while(A[i] == elem && i < n){

题目描述给出一个用二维矩阵表示的图像返回该图像顺时针旋转90度的结果扩展：你能使用原地算法解决这个问题么？class Solution {public: void rotate(vector<vector<int> > &matrix) { int temp; int n = matrix.size(); int m = matrix[0].size(); for(int i = 0; i

题目描述继续思考“n-queens”问题 这次我们不是输出皇后的排列情况，而是输出n皇后问题一共有多少种解法正解class Solution {public: /** * * @param n int整型 * @return int整型 */ int totalNQueens(int n) { // write code here int res = 0; // ??? v

题目描述请计算给出的数组（至少含有一个数字）中具有最大和的子数组（子数组要求在原数组中连续）例如：给出的数组为[−2,0,−3,4,−2,2,2,−5,4],子数组[−2,0,−3,4,−2,2,2,−5,4],具有最大的和:6.class Solution {public: /** * * @param A int整型一维数组 * @param n int A数组长度 * @return int整型 */ int maxS

题目描述给定一个整数n，将数字1到n^2n2按螺旋的顺序填入n×n的矩阵例如：给出的n=3，你应该返回如下矩阵：[[ 1, 2, 3 ],[ 8, 9, 4 ],[ 7, 6, 5 ]]class Solution {public: /** * * @param n int整型 * @return int整型vector<vector<>> */ vector<vector<int&

题目描述一个机器人在m×n大小的地图的左上角（起点）。机器人每次向下或向右移动。机器人要到达地图的右下角（终点）。可以有多少种不同的路径从起点走到终点？备注：m和n小于等于100,并保证计算结果在int范围内class Solution {public: /** * * @param m int整型 * @param n int整型 * @return int整型 */ int uniquePaths(int m, in

题目描述将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的，且合并后新链表依然有序。/** * struct ListNode { * int val; * struct ListNode *next; * }; */class Solution {public: /** * * @param l1 ListNode类 * @param l2 ListNode类 * @return ListNode类

题目描述实现函数 int sqrt(int x).计算并返回x的平方根（向下取整）class Solution {public: /** * * @param x int整型 * @return int整型 */ int sqrt(int x) { // write code here if(x < 2){ return x; } int le

题目描述你在爬楼梯，需要n步才能爬到楼梯顶部每次你只能向上爬1步或者2步。有多少种方法可以爬到楼梯顶部？class Solution {public: /** * * @param n int整型 * @return int整型 */ int climbStairs(int n) { // write code here // f(n) = f(n-1) + f(n-2) // f(1)

题目描述给定一个m*n的矩阵，如果有一个元素是0，就把该元素所在的行和列上的元素全置为0，要求使用原地算法。拓展：你的算法有使用额外的空间吗？一种比较直接的算法是利用O(m,n)的空间，但是这不是一个好的解法使用简单的改进可以在O(m+n)的空间解决这个问题，但是还不是最佳的解法你能在常量级的空间复杂度内解决这个问题吗？class Solution {public: void setZeroes(vector<vector<int> > &matr

题目描述现在有一个包含n个物体的数组，其中物体颜色为颜色为红色、白色或蓝色，请对这个数组进行排序，让相同颜色的物体相邻，颜色的顺序为红色，白色，蓝色。我们用0,1,2分别代表颜色红，白，蓝注意：本题要求你不能使用排序库函数扩展：一个非常直接的解法是两步的计数排序的算法首先：遍历一遍数组，记录0,1,2的数量，然后重写这个数组，先将0写入，再将1写入，再将2写入你能给出一个只用一步，并且能在常数级空间复杂度解决这个问题的算法吗？class Solution {public: v

题目描述删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次例如：给出的链表为1\to1\to21→1→2,返回1 \to 21→2.给出的链表为1\to1\to 2 \to 3 \to 31→1→2→3→3,返回1\to 2 \to 31→2→3./** * struct ListNode { * int val; * struct ListNode *next; * }; */class Solution {public: /**

题目描述给出一棵二叉树，返回这棵树的中序遍历例如：给出的二叉树为{1,#,2,3},1\2/3返回[1,3,2].备注：递归的解法太没有新意了，你能用迭代的方法来解这道题吗？/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param

题目描述给定一个值n，能构建出多少不同的值包含1…n的二叉搜索树（BST）？例如给定 n = 3, 有五种不同的二叉搜索树（BST）class Solution {public: /** * * @param n int整型 * @return int整型 */ int numTrees(int n) { // write code here vector<int> result(n+1,

题目描述本题要求判断给定的二叉树是否是平衡二叉树平衡二叉树的性质为: 要么是一棵空树，要么任何一个节点的左右子树高度差的绝对值不超过 1。一颗树的高度指的是树的根节点到所有节点的距离中的最大值。/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @par

题目描述 给定一个二叉树struct TreeLinkNode {TreeLinkNode *left;TreeLinkNode *right;TreeLinkNode *next;}填充所有节点的next指针，指向最接近它的同一层右边节点。如果没有同一层没有右边的节点，则应该将next指针设置为NULL。 初始时，所有的next指针都为NULL 注意： 你只能使用常量级的额外内存空间可以假设给出的二叉树是一个完美的二叉树(即，所有叶子节点都位于同一层，而且每个父节点都有两个孩子节点)。.

假设你有一个数组，其中第\ i i 个元素是股票在第\ i i 天的价格。你有一次买入和卖出的机会。（只有买入了股票以后才能卖出）。请你设计一个算法来计算可以获得的最大收益。class Solution {public: /** * * @param prices int整型vector * @return int整型 */ int maxProfit(vector<int>& prices) { //.

给定一个m x n大小的矩阵（m行，n列），按螺旋的顺序返回矩阵中的所有元素。class Solution {public: vector<int> spiralOrder(vector<vector<int> > &matrix) { vector<int> res; if(matrix.empty()){ return res; } int ro.

给出两个二叉树，请写出一个判断两个二叉树是否相等的函数。判断两个二叉树相等的条件是：两个二叉树的结构相同，并且相同的节点上具有相同的值。/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param p TreeNode类 * @param q.

假设你有一个数组，其中第i个元素表示某只股票在第i天的价格。设计一个算法来寻找最大的利润。你可以完成任意数量的交易(例如，多次购买和出售股票的一股)。但是，你不能同时进行多个交易(即，你必须在再次购买之前卖出之前买的股票)。class Solution {public: /** * * @param prices int整型vector * @return int整型 */ int maxProfit(vector<int>&.

class Solution {public: /** * * @param A int整型一维数组 * @param n int A数组长度 * @return int整型 */ int singleNumber(int* A, int n) { // write code here int result = 0; for(int i = 0; i < n; i++){

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: bool hasCycle(ListNode *head) { if(!head) return false;

二叉树的最大深度（递归）/** * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */class Solution {public: /** * * @param root TreeNode类 * @return int整型 */ int maxDepth(TreeNode* root) {

前序遍历和后续遍历前序遍历的顺序是：根 左 右 ；压栈顺序就是根 右 左后续遍历：左 右 根 ；可以通过根 右 左 的顺序遍历，最后反序得到；压栈顺序：根 左 右中序遍历：注意根不能先入栈了，利用一个移动结点，在while内入栈，不断左 入栈，最后出栈 ，再压右# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right =.

计算逆波兰式（后缀表达式）的值运算符仅包含"+","-","*“和”/"，被操作数可能是整数或其他表达式例如：["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6示例1输入:["2","1","+","3","*"]输出:9必备知识：我们可以用一个栈S来实现计算，扫描从左往右进行，如果扫描到操作数，则压进S，如果扫描.

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。递归，若为空树返回0；若左右子树都为空，则返回+1若左子树为空，则返回右子树的最小深度+1；若右子树为空，则返回左子树的最小深度+1；若左右子树均不为空，则取左、右子树最小深度的较小值，+1；# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left