- 博客(195)
- 资源 (7)
- 收藏
- 关注
RSS订阅原创 2015/10/06写下的归并排序、快速排序、二分查找
#include<iostream>using namespace std;void merge(int a[], int start, int middle, int end){ int index1 = start; int index2 = middle + 1; int * buffer = new int[end - start + 1]; int co
2015-10-06 20:56:00
528
原创 sizeof和strlen
sizeofsizeof是一个操作符关键字，返回的结果为 size_t (typedef unsigned int size_t;)sizeof的参数可以是数据类型，也可以是变量，无论是变量还是数据类型，都会转化为数据类型作为参数，因为在C语言中变量是有类型的。发生在编译时候就计算出了sizeof结果sizeof计算的是数据类型占内存的大小数组做sizeof参数不退化。char a[5]sizeo
2015-09-09 17:25:42
407
原创 C++中右移和左移
关于移位操作：“<<” 左移位操作：从右边开始用0补空位 “>>”右移位操作：对于无符号数从左边开始补0；对于有符号数，或者补符号位，或者补0，由编译器决定（gcc的编译器是补符号位）注意：移位的数目是负数或者移位出界时（最多只能移位类型二进制位大小-1），这个操作符的行为是未定义的，位操作只针对整数类型(int long等)或者char类型的数据
2015-09-09 10:45:22
3702
原创 LeetCode(268) Missing Number
数学方法class Solution {public: int missingNumber(vector<int>& nums) { //math solution by sum total int sum = nums.size() * (nums.size() + 1) / 2; for(int i = 0; i < nums.size(
2015-08-30 10:15:29
406
原创 LeetCode(264) Ugly Number II
不知道为什么注释掉的三条if语句不和下面的两条语句等价。一个导致结果是正确的，一个导致是错误的，想不通。class Solution {public: int nthUglyNumber(int n) { int id2 = 0; int id3 = 0; int id5 = 0; int rst = 1; int counter = 2; v
2015-08-30 09:39:39
551
原创 LeetCode(263) Ugly Number
c++代码如下class Solution {public: bool isUgly(int num) { if(num <= 0) return false; while(num % 2 == 0) num = num / 2; while(num % 3 == 0) num = num / 3; while(num % 5 ==
2015-08-29 22:24:30
307
原创 LeetCode(260) Single Number III
参考https://leetcode.com/discuss/52757/16ms-c-solution 大概的思路： 1、make a filter 2、取出相应位不为0的数 3、再算出另一个数class Solution {public: vector<int> singleNumber(vector<int>& nums) { //make a filter
2015-08-29 18:30:13
349
转载 C++中map、hash_map、unordered_map、unordered_set通俗辨析
转载http://blog.csdn.net/u013195320/article/details/23046305标题中提到的四种容器，对于概念不清的人来说，经常容易弄混淆。这里我不去把库里面复杂的原码拿出剖析，这个如果有兴趣其实完全可以查C++Reference,网上的原码是最权威和细致的了，而且我觉得有耐心直接认真看原码的人，也不需要我这篇速记博文了，所以我这里还是讲的通俗一些，把它们区分的七
2015-08-29 16:46:06
853
原创 LeetCode(258) Add Digits
根据维基百科的公式即可，其实本题如果按照原始的暴力求解，迭代次数不会超过个位次，最大的数字和的整数为1999999999，加起来瞬间缩小到82，下次会更小，很快就会得到答案，何必呢 https://en.wikipedia.org/wiki/Digital_root代码如下：class Solution {public: int addDigits(int num) { r
2015-08-29 16:41:17
332
原创 LeetCode(257) Binary Tree Paths
c++代码如下/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; *
2015-08-29 16:09:06
420
原创 LeetCode(242) Valid Anagram
class Solution {public: bool isAnagram(string s, string t) { sort(s.begin(), s.end()); sort(t.begin(), t.end()); if(s.size() != t.size()) return false; for(int i = 0;
2015-08-29 14:15:00
504
原创 LeetCode(241) Different Ways to Add Parentheses
在写递归程序时，我不能追踪整个调用过程，如果我这样做，随着递归过程的不断深入，我会觉得累，没有脑力，也没有精力，最终迷失在调用过程，不知道自己在干什么，处于什么方位。我只能关注衔接， 只能关注各种衔接 两层调用树之间的衔接，可能这就是递归编程的本质 c++代码如下class Solution {public: vector<int> diffWaysToCompute(strin
2015-08-29 13:18:51
499
原创 LeetCode(240) Search a 2D Matrix II
如何寻找到一条合适的搜索路径是是解决本题的核心部分，二分搜索在这里是不适用的。我一直试图利用每一行非递减序，每一列非递减序这两条特性来寻找复杂度较小的搜索路径，最后的结果是我并没能充分利用这两条性质。后来在discuss里发现了充分利用两条性质的解决方案，我将其改成迭代版本，更加清晰明了。 discuss链接：https://leetcode.com/discuss/53535/so-clear-
2015-08-29 10:57:55
303
原创 LeetCode(238) Product of Array Except Self
一开始最直接的思路当然是：对于0号位置元素，将剩下的元素依次累乘，然后保存；对于1号位置，重复上述动作。可是题目的意思是我们只能在o(n)时间内完成，上述算法的时间的复杂度是o(n^2)，下面在已有方案上优化，优化的方法是找出冗余计算，我们发现：以0号位置和1号位置为例，如果我们已经知道0号位置对应的乘积为p，那么1号位置对应的乘积为p/nums[1]*nums[0],即0号位置和1号位置对应的乘积
2015-08-28 22:10:25
348
原创 LeetCode(237) Delete Node in a Linked List
由于单向链表的不可逆向性，所以一定不可能改变2号位置的指针域，即3号位置的内存一定要用；另一方面，根据函数结果，4这个值一定出现在3号位置。所以一定有的操作是将4这个值放入3号位置，由此整个解决方案浮出水面。突然间发现我开始思考着推理着逻辑着编程了，哈哈 c++代码如下/** * Definition for singly-linked list. * struct ListNode { *
2015-08-28 21:31:47
382
原创 LeetCode(236) Lowest Common Ancestor of a Binary Tree
与LeetCode235的思路一样 先分别搜索出两个节点的父节点序列，然后再找出最低的节点。不过这里搜索父亲节点序列就没有那么简单了，需要用到深度优先搜索。在实现深度优先搜索时感觉又不会了，╮(╯▽╰)╭，花了好长时间c++代码如下/** * Definition for a binary tree node. * struct TreeNode { * int val; *
2015-08-28 17:57:09
315
原创 LeetCode(235) Lowest Common Ancestor of a Binary Search Tree
先分别搜索出两个节点的父节点序列，然后再找出最低的节点c++代码如下/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NUL
2015-08-28 17:52:38
317
原创 LeetCode(234) Palindrome Linked List
1、用快慢指针找到链表中心位置 如果链表长度为偶数个，比如1,2,3,4，最后找到3 如果链表长度为奇数个，比如1,2,3,4,5，最好找到3 2、将后半段反转 3、从一头一尾状态开始判断是否为回文 c++代码如下/** * Definition for singly-linked list. * struct ListNode { * int val; *
2015-08-28 13:07:08
319
原创 LeetCode(233) Number of Digit One
总的思想是先分类（个位，十位，百位），再对各种情况进行统计（前缀有多少种，后缀有多少种，并利用相乘原理）。 以3141592为例，数字1出现在个位，十位，百位，千位，万等等。 下面开始对各种情况进行统计： 1、出现在个位的1的数量为 000000 1 . . . 314158 1 把最后的前缀314159单独考虑 2、出现在百位的1的数量为
2015-08-28 10:58:54
450
原创 一些经常被问到的问题
1、new和malloc的区别？共性：malloc与free是C++/C语言的标准库函数， new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。特性：1、对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够
2015-08-17 10:13:24
344
原创 算法武器
正规的算法：DFS，回溯，分治，BFS，动态规划。。。使用数据结构的算法： map, set, stack, queue。。。轻功算法：将扫描过的元素保存到某种数据结构以达到某种目的； 各种双指针算法 滑动窗口法 模拟算法（常用于链表）。。。
2015-08-17 09:22:00
376
原创 LeetCode(227) Basic Calculator II
做 LeetCode(224) Basic Calculator时用了栈来实现，原本想在基础上进行稍稍改变即可，可是越改越不可控，后来发现在discuss中提供了不使用栈的很简单的代码。https://leetcode.com/discuss/42643/my-16-ms-no-stack-one-pass-short-c-solution 至于原理，自己用一个例子代入就可以了解，大概思路如下：
2015-08-16 22:23:22
317
原创 LeetCode(230) Kth Smallest Element in a BST
利用对二叉查找树进行中序遍历的结果是升序排列这个特性进行解答/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL),
2015-08-16 20:37:47
349
原创 LeetCode(229) Majority Element II
将扫描过的数组用另一种数据结构保存起来，已达到某种目的。class Solution {public: vector<int> majorityElement(vector<int>& nums) { vector<int> result; map<int, int> map1; int length = nums.size();
2015-08-16 20:26:16
259
原创 LeetCode(224) Basic Calculator
本题并没有什么难度，就是稍微烦点 c++代码如下class Solution {public: int calculate(string s) { //if(s == "(1)") return 1; //if(s == "1+(2+3)") return 6; stack<string> stack1; for(int ind
2015-08-16 17:16:01
291
原创 LeetCode(222) Count Complete Tree Nodes
隐隐约约感觉用到了剪枝的思想。 第一步：首先计算一路向左的深度，一路向右的深度 第二步：如果相等，则为满二叉树，返回2^depth - 1; 第三步：如果不等，则用递归函数实现递推关系 树的节点数 = 左子树的节点数 + 右子树的节点数 + 1其中第二步就是对第三步的优化，我们如果不加思考一直使用递推也是可以的，只不过时间比较长，会出现LTE。使每个子函数尽可能早的
2015-08-16 15:54:51
395
原创 LeetCode(220) Contains Duplicate III
基本原理是：将扫描过的最后k个元素（在一开始时，二叉查找树的大小是由1变化到k,然后保持k不变）放入二叉查找树这个有序的数据结构，利用其两个成员函数set1.lower_bound(nums[i]);set1.upper_bound(nums[i]);lower_bound(nums[i]) : 大于等于nums[i]的第一个元素。 upper_bound(nums[i])：大于nums[i]的
2015-08-16 14:42:34
264
原创 LeetCode(216) Combination Sum III
两种稍微不同的DFS，正在研究中。。。class Solution {public: void dfs(vector<int> nums, int start, int depth, vector<int> &output, vector<vector<int>> &result, int k, int target) { if(start + k - depth > 9) r
2015-08-15 22:24:30
328
原创 LeetCode(215) Kth Largest Element in an Array
还没回过神来，这道题就解决了，我也是醉了class Solution {public: int findKthLargest(vector<int>& nums, int k) { sort(nums.begin(), nums.end()); reverse(nums.begin(), nums.end()); return nums[k -
2015-08-15 19:15:21
248
原创 LeetCode(211) Add and Search Word - Data structure design
用递归来实现递推class TrieNode {public: int val; TrieNode *children[26]; // Initialize your data structure here. TrieNode() { val = 0; for (int i=0; i < 26; i++) children[i] = NUL
2015-08-15 19:11:55
379
原创 LeetCode(209) Minimum Size Subarray Sum
花了比较长的时间理解滑动窗口法的原理，至于在什么情况下想到用滑动窗口法，以及滑动窗口话的原理可以参考下面两篇博文，写的非常好。 在什么情况下用滑动窗口法博文 滑动窗口法的原理博文 下面的代码我应该当做模板背诵，keep in mind this solution as template. 代码如下：class Solution {public: int minSubArrayLen
2015-08-15 08:20:17
230
原创 LeetCode(208) Implement Trie (Prefix Tree)
参考Yu’s Coding Garden之后发现在Trie结构体中的count是没有必要的，所以删去。本题也促使我思考所谓的“树”，所谓的“图”究竟是什么；所谓的“栈”，所谓的“map容器”。组织数据的方式，不是数据，不是结构体。代码如下：class TrieNode {public: int val; TrieNode *children[26]; // Initialize
2015-08-13 21:59:31
288
原创 LeetCode(207) Course Schedule
一开始程序一直TLE，经过一天的调试，发现将graph参数变成引用传递就可以通过了，不过时间依然很长，大概500ms左右。后来引入节点三状态，时间缩减到250ms左右，但原因还不是十分明朗。500ms代码class Solution {public: void dfs(vector<vector<int>> &graph, int start, vector<int> &visited, b
2015-08-13 18:26:05
244
原创 2015/08/12一些想法
我倾向于共性， 刘雪倾向于特性，比如剑指offer的那道问题，她通过代入验证认为这个公式是合理的，也考虑了下大概什么，我往往倾向于递推关系，大问题小问题。关于看不懂怎么办，彦峰提出了一个不同于我的解决方案，一直继续向下看，慢慢体会，然后再看第二遍就会好很多。我是立即停下来寻找相应的理论。对于抽象的东西比如人与人之间的关系，刘雪反问难道你感受不到吗
2015-08-12 21:01:29
304
原创 LeetCode(201) Bitwise AND of Numbers Range
参考program creekclass Solution {public: int rangeBitwiseAnd(int m, int n) { while(n > m) n = n & n - 1; return n & m; }};
2015-08-12 11:10:25
309
原创 LeetCode(200) Number of Islands
BFS广度优先搜索class Solution {public: void bfs(vector<vector<char>>& grid, int i, int j, int length, int width) { queue<pair<int, int>> que; grid[i][j] = '#'; que.push(make_pair(i
2015-08-12 10:30:22
271
原创 LeetCode(199) Binary Tree Right Side View
map算法/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */
2015-08-11 22:28:52
272
原创 LeetCode(187) Repeated DNA Sequences
基本思路:从前向后遍历所有长度为10子序列，然后将结果存放到map容器中并记录出现的次数，如果大于1，则保存。一开始键值对是这样写的：ACGT GCGT AA -> 1（出现的次数）发现内存超出。经过一次中间变换：ACGT GCGT AA 双射 1234 3234 11 （long long 整型）键值对变成如下这样1234 3234 11
2015-08-11 22:09:12
236
原创 LeetCode(179) Largest Number
貌似用到了自己定义的比较函数，不太懂，以后一定会慢慢懂得。 先过。参考discussclass Solution {public: string largestNumber(vector<int>& nums) { string result; sort(nums.begin(), nums.end(), [](int a, int b) { return t
2015-08-11 16:26:09
249
The Algorithm Design Manual-Steve S. Skiena Second Edition
2015-07-08
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人