flowertree花树-CSDN博客

原创机器学习-主成分分析PCA新的理解

这两天重新看了PCA的相关知识，重新理解了下数学推导，这篇文章把该讲的都讲了，附上链接。下面是一点理解，再迷惑的时候看看。http://blog.codinglabs.org/articles/pca-tutorial.html根据上述推导，我们发现要达到优化目前，等价于将协方差矩阵对角化：即除对角线外的其它元素化为0，并且在对角线上将元素按大小从上到下排列，这样我们就达到了优化目

2016-06-26 16:39:32 254

转载机器学习梯度下降法

转载的他人的一篇文章。回归(regression)、梯度下降(gradient descent)本文由LeftNotEasy所有，发布于http://leftnoteasy.cnblogs.com。如果转载，请注明出处，在未经作者同意下将本文用于商业用途，将追究其法律责任。前言:上次写过一篇关于贝叶斯概率论的数学，最近时间比较紧，coding的任务比较重，不过还是抽空看

2016-05-03 21:52:32 272 3

原创剑指offer 二叉搜索树的第k个结点

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

2016-05-01 18:00:48 221

原创剑指offer 扑克牌顺子

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

2016-05-01 18:00:40 147

原创剑指offer 和为S的连续正数序列

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

2016-05-01 18:00:33 131

原创剑指offer 数组中重复的数字

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

2016-05-01 18:00:30 135

原创剑指offer 机器人的运动范围

标准的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

2016-05-01 18:00:00 181

原创剑指offer 孩子们的游戏(圆圈中最后剩下的数)

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

2016-05-01 17:59:49 214

原创二叉树的遍历方式-递归与非递归

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

2016-05-01 17:59:22 163

原创剑指offer 和为S的两个数字

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

2016-04-29 17:27:20 115

原创剑指offer 左旋转字符串

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

2016-04-29 17:25:23 128

原创剑指offer 把字符串转换成整数

简单题目。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();

2016-04-29 17:23:11 120

原创剑指offer 构建乘积数组

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

2016-04-29 17:19:47 130

原创剑指offer 对称的二叉树

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

2016-04-29 17:13:54 134

原创剑指offer 表示数值的字符串

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

2016-04-29 16:57:13 97

原创剑指offer 二叉树的下一个结点

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

2016-04-29 16:55:20 112

原创剑指offer 按之字形顺序打印二叉树

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

2016-04-29 16:42:33 147

原创剑指offer 把二叉树打印成多行

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

2016-04-29 16:39:20 123

原创剑指offer 数组中只出现一次的数字

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

2016-04-29 16:14:58 130

原创剑指offer 数字在排序数组中出现的次数

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

2016-04-29 15:47:16 152

原创剑指offer 二叉树的深度

深度优先搜索，递归。/*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

2016-04-29 15:20:23 130

原创剑指offer 平衡二叉树

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

2016-04-29 15:15:59 168

原创剑指offer 两个链表的第一个公共结点

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

2016-04-29 14:51:25 129

原创剑指offer 丑数

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

2016-04-29 14:18:17 137

原创剑指offer 连续子数组的最大和

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

2016-04-29 13:55:31 92

原创剑指offer 二叉搜索树与双向链表

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

2016-04-29 13:53:01 127

原创剑指offer 复杂链表的复制

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

2016-04-29 12:21:00 116 1

原创剑指offer 二叉树中和为某一值的路径

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

2016-04-29 11:57:18 164

原创剑指offer 包含min函数的栈

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

2016-04-29 11:36:18 139

原创剑指offer 滑动窗口的最大值

class Solution {public: vector maxInWindows(const vector& a, unsigned int k){ vector res; deque s; for(unsigned int i = 0; i < a.size(); ++i){ while(s.size() &

2016-04-26 17:10:08 125

原创剑指offer 二叉搜索树的后序遍历序列

分治递归。class Solution {public: bool VerifySquenceOfBST(vector sequence) { int len = sequence.size(); if(len == 0) return false; if(len == 1) return true;

2016-04-26 11:01:01 112

原创剑指offer 矩形覆盖

class Solution {public: int rectCover(int number) { if(number == 0) return 1; int a[10005]; a[1] = 1; a[2] = 2; for(int i = 3; i < 10005; i++)

2016-04-25 22:01:31 117

原创剑指offer 第一个只出现一次的字符位置

class Solution {public: int FirstNotRepeatingChar(string str) { if(str.length() == 0) return -1; int len = str.length(); int temp; int num[52];

2016-04-25 21:56:14 119

原创剑指offer 旋转数组的最小数字

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

2016-04-25 21:33:17 114

原创剑指offer 数组中出现次数超过一半的数字

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

2016-04-25 21:31:53 125

原创剑指offer 从上往下打印二叉树

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

2016-04-25 21:18:07 89

原创剑指offer 链表中倒数第k个结点

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

2016-04-25 19:41:20 110

原创剑指offer 反转链表

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

2016-04-25 17:55:22 152 2

原创剑指offer 二叉树的镜像

递归反转。/*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

2016-04-25 17:49:51 146

原创剑指offer 斐波那契数列

递推，空间复杂度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;

2016-04-25 17:46:08 140 1

空空如也

空空如也