思路：这个题有个小技巧，先算出总共的空格数，然后我们就知道了每个字符的位移距离，然后从最后一个字符开始位移。 class Solution { public: void replaceSpace(char *str,int length) { if(str == NULL) return ; if(*str == '\0')

注意这个地方vector的用法。没什么难度。 class Solution { public: vector multiply(const vector& A) { vector res; int len = A.size(); if(len == 0) return res; res.resize(

很好的一道题，两个思路很经典。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ //解法1：中序遍历看是不是

操蛋的一个题，某大神写的，自己实在没精力研究这么细。 class Solution { public: bool isNumeric(char* string) { int i = 0; if(string[i]=='+' || string[i]=='-' || IsNum(string[i])){ while(strin

分多种情况讨论，很好的一道题。 using namespace std; /* struct TreeLinkNode { int val; struct TreeLinkNode *left; struct TreeLinkNode *right; struct TreeLinkNode *next; TreeLinkNode(int x) :val(x

按之字形，类似于前面一个打印二叉树的程序，那个题用两个队列，这个题用两个栈，代码用的寒假写的代码，没重新写，因为差不多。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NU

利用两个队列，还有一道题是之字形输出二叉树，是用两个栈，步骤基本相同。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { }

这个题有个大坑坑了我很长时间，在判断中先算&算!=，不然会出错，亲测。 再所有条件中建议都稳健的加括号。 class Solution { public: void FindNumsAppearOnce(vector data,int* num1,int *num2) { int len = data.size(); if(len < 2)

本来想偷偷用遍历水过，但是这样做练习就没意义了，本来想的是二分找到第一个K，然后前后遍历找到第一个K和最后一个K，然后返回他们的差。这样做的话时间复杂度为O(n)，因为遍历的存在，这样和第一个解法没什么区别，虽然提高了一点时间效率。翻了翻书，正确的解法是不停二分查找第一个K和第二个K，这样得到了O(logN)的最小复杂度。这是个练习二分的好题目。 class Solution { public:

深度优先搜索，递归。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: int TreeDepth(T

简单题目。 class Solution { public: int StrToInt(string str) { if(str.size() == 0) return 0; int num = 0; bool flag = false; for(int i = 0; i < str.size();

巧妙地三次旋转。 class Solution { public: string LeftRotateString(string str, int n) { int len = str.length(); if(len == 0) return str; if(n <= 0) return s

前面1个月学完了机器学习方面，基础知识学完了，但是还有很多欠缺，数学推理也不好，还有很多高大上的没有涉及。这几天复习一下好长时间之前的题目，《剑指offer》的经典题目，一共66道题，有意义的50道左右，这4天把它们做完为找工作做准备。 思路很简单，从右上角或者左下角开始寻找，每次根据比角上的数大或小排除一行或一列，找到为true，找不到为false。 class Solution { pub

之前寒假做了这道题用队列，队列存中序遍历的结果，然后输出第K个，这样需要浪费空间，今天重新做了一次，空间复杂度为0。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL

很有意思的一道模拟题。 class Solution { public: bool IsContinuous( vector numbers ) { int jokers = 0; int len = numbers.size(); if(len != 5) return false; for(int

数学公式的推导。 class Solution { public: vector > FindContinuousSequence(int sum) { vector > res; vector t; int temp1, temp2; int x; if(sum < 3) retur

思路很棒，每一个数字去找它应在的位置。 class Solution { public: // Parameters: // numbers: an array of integers // length: the length of array numbers // duplication: (Outp

标准的dfs。 class Solution { public: int getSum(int n){//数字各位求和 int sum = 0; for(int m = 1; m <= n; m *= 10){ sum += (n/m) % 10; } return sum; } vo

约瑟夫环。 有个简单的推导过程，我们可以根据每x个人出环得出从最后到开始每一次出环的人的编号。这里不再说明。 class Solution { public: int LastRemaining_Solution(unsigned int n, unsigned int m) { if(n == 0 || m == 0) return -

//============================================================================ // // > File : // > Author : flowertree // > Time : 2016年4月24日 // > Algorith

经典的前后指针向中逼近的题目。 class Solution { public: vector FindNumbersWithSum(vector array,int sum) { vector re; int left = 0; int right = array.size() - 1; while(left < righ

处理好树高引用这一点，递归实现。、 class Solution { public: bool IsBalanced_Solution(TreeNode* pRoot) { if(pRoot == NULL) return true; int high; return isbalance(pRoot, high); }

/*struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2)

原poj上的题目，做过，又重新理了下思路。 只是这个代码太过繁琐。 class Solution { public: int GetUglyNumber_Solution(int index) { if(index == 0) return 0; int u[10005]; u[1] = 1; int u

继续干，广度优先搜索。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: vector PrintFr

先走k个结点，然后头指针和先走的节点一起走，直到先走的节点到最后的NULL，注意过程中的越界处理。 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* Find

/* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* ReverseList(ListNode* pHead) { if(pHead == NULL

递归反转。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: void Mirror(TreeNode

跳台阶的加强版。 class Solution { public: int jumpFloor(int number) { int temp1, temp2, temp; if(number == 1) return 1; if(number == 2) return 2; t

递推，空间复杂度O(1)。 class Solution { public: int Fibonacci(int n) { if(n == 0) return 0; if(n == 1) return 1; int temp1, temp2, temp3; temp1 = 0;

简单递推，空间复杂度O(1) class Solution { public: int jumpFloor(int number) { int temp1, temp2, temp; if(number == 1) return 1; if(number == 2) return 2;

快速二分幂 class Solution { public: double Power(double base, int exponent) { if(exponent == 0) return 1; if(exponent == 1) return base; int temp = abs(

两个函数递归完成 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: bool HasSubtree(T

每一个超过一半的数抵消一个其他的数，最后剩下的数为超过一半的数。 class Solution { public: int MoreThanHalfNum_Solution(vector numbers) { int len = numbers.size(); if(len == 0) return 0; int numb

特别脏的方法。 class Solution { public: int minNumberInRotateArray(vector rotateArray) { int len = rotateArray.size(); if(len == 1) return rotateArray[0]; int last =

动态规划。 class Solution { public: int FindGreatestSumOfSubArray(vector array) { int sum = 0; int maxsum = 0xFFFFFFFF; int len = array.size(); if(len == 0) re

挺难的一道题。 class Solution { public: TreeNode* Convert(TreeNode* pRootOfTree) { if(pRootOfTree == NULL) return pRootOfTree; pRootOfTree = ConvertNode(pRootOfTree); while(p

分三步，分别在注释里。 /* struct RandomListNode { int label; struct RandomListNode *next, *random; RandomListNode(int x) : label(x), next(NULL), random(NULL) { } }; */ class Solution

深度优先搜索，这个题有个坑是路径必须为根节点到叶子，路途中路径和满足最终路径和也不行。需要加上当前节点是否为叶子节点的判断。 这个题很好的应用了二维vector，是个练习STL的好题。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val

刚回到家，玩了很长时间，看完了比赛，敲点代码。 这个题用两个栈实现，一个为正常的栈，一个为存当前最小值的栈，很容易维护。 class Solution { private: stack data, mindata; public: void push(int value) { data.push(value); if(mindata.em