wcxdell的专栏

好久不写C++了，觉得面试写代码什么的挺重要的，所以从现在开始刷LeetCode题目，不过现在还早，不用太着急，没事刷两道就好。本题就是博弈论，一行代码解决class Solution {public:    bool canWinNim(int n) {        return n%4;            }};

下面是一个屎一样的写法class Solution {public:    int addDigits(int num) {        int addNum = 0;        while (1) {            while (1) {                addNum += num % 10;                if (nu

/** * Definition for a binary tree node. * struct TreeNode { *     int val; *     TreeNode *left; *     TreeNode *right; *     TreeNode(int x) : val(x), left(NULL), right(NULL) {} * };

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     ListNode *next; *     ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public:    vo

class Solution {public:    void moveZeroes(vector& nums) {        if (!nums.size()) return;        int ZeroNum = 0;        int indexNum = 0;        for (int i=0; i            if (nums[i]

用到了向量和pair。class Solution {public:    string reverseVowels(string s) {        vector> vec;        for (int i = 0;i            if(s[i] == 'a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=

主要是利用二叉搜索树的性质，即左节点一定小于根节点，右节点一定大于根节点。那么只要从上向下找到一个值介于给定两个节点的值的节点久可以了。class Solution {public: TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { if (p->val v

注意特殊情况的判断。class Solution {public:    TreeNode* invertTree(TreeNode* root) {        if (root == NULL) return NULL;                TreeNode *tmp = root->left;        root->left

也是注意特殊情况的判断class Solution {public:    bool isSameTree(TreeNode* p, TreeNode* q) {        if (p == NULL && q == NULL) return true;        if (p == NULL && q != NULL) return false;     

就是判断是不是由同一组字母构成的。两种方法，判断相同字母出现的次数：class Solution {public:bool isAnagram(string s, string t) { if (s.size()!=t.size()) return false; int a[26] = {0}; int b[26] = {0}; fo

实质就是26进制，从头到尾去处理就好了，用pow函数方便多了。class Solution {public: int titleToNumber(string s) { int sum = 0; for (int i = 0;i<s.size();i++){ sum += (s[i] - 'A' +1)*pow(26,s.siz

我原本想用计数排序来做，就是下面的样子；class Solution {public: bool containsDuplicate(vector& nums) { int a[999999] = {0}; for (int i = 0 ;i < nums.size(); i++){ a[nums[i]]++;

简单的链表合并问题，注意三种情况，两个头都不为空，一个为空和都为空。另外，先有一个无用的头是一个很好的方法，不用判断是不是第一次。class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode *head = new ListNode(0);

注意只能换节点，不能换值。class Solution {public: ListNode* swapPairs(ListNode* head) { ListNode *cur = head; ListNode *preCur = NULL; if(head&&head->next) head = head->next;

这是我真正意义上理解DP的原理之后解出来的题。对于第n个房间如果拿：那么上一个房间肯定没拿，那就是   maxMoney(n) = 没拿(n-1)+nums[n];如果没拿：那么没拿(n) = maxMoney(n-1);这里我用dp0代表没拿(n-1);dp1代表maxMoney(n-1);class Solution {

一次过，但是写出来的代码并不是最高效。class Solution {public: bool isBalanced(TreeNode* root) { if (!root) return true; if(abs(height(root->left)-height(root->right))>1) return false; retu

层次遍历，本来一个循环就可以，但是要输出一个二位数组，就变成嵌套循环了。然后把结果逆序一下就可以了。class Solution {public: vector> levelOrderBottom(TreeNode* root) { vector> res; if(!root) return res; queue que;

和107差了一个逆序class Solution {public: vector> levelOrder(TreeNode* root) { vector> res; if(!root) return res; queue que; que.push(root); while(que.size

使用了pair，元素相同就＋1，不同就－1.最后剩下的那个就是。 int majorityElement(vector& nums) { pair p(0,0); for (int i=0 ;i<nums.size(); i++){ if (p.first != nums[i]){ i

用一个临时的节点表示head要指向的地址；然后head，和临时节点同步向前移动。class Solution {public: ListNode* reverseList(ListNode* head) { ListNode* pre = NULL; while(head){ ListNode* next = head->next;

主要思路是记录下翻转的链表的头和尾，分别赋值。ListNode* reverseBetween(ListNode* head, int m, int n) { ListNode* pre = NULL; ListNode* cur = head; ListNode* tmpTail; for (int i = 1 ; i < m;i++){ pr

这道题主要是要知道罗马转数字的规则，前边的比后边的小就要减。 int romanToInt(string s) { int a[26] = {0}; a['I'-'A'] = 1; a['V'-'A'] = 5; a['X'-'A'] = 10; a['L'-'A'] = 50; a['C'-'A'] = 100; a['D

递归版class Solution {private: bool symmetric(TreeNode* left,TreeNode* right){ if(!left&&!right) return true; else if(left&&!right || !left&&right) return false; else{

提高效率的方式是把最后一个挪到删除的地方来。 int removeElement(vector& nums, int val) { int size = nums.size(); for(int i = 0;i<size;){ if(nums[i] == val){ nums[i] = num

用两个栈实现一个队列。class Queue {public: stack s1; stack s2; // Push element x to the back of queue. void push(int x) { s1.push(x); } // Removes the element from in front of

主要注意一下进位，和数组长度不足的情况。 vector plusOne(vector& digits) { for(int i = digits.size() - 1;i>=0;i--){ if(digits[i]<9) { digits[i]++; break;

这是一个数学问题，要用到等比数列的知识，大部分人已经忘了吧。。。给个别人的答案。 bool isPowerOfFour(int num) { return num > 0 && (num & (num - 1)) == 0 && (num - 1) % 3 == 0; }

杨辉三角：class Solution {public: vector> generate(int numRows) { vector> vec; for(int i=0;i<numRows;i++){ vector tmp(i+1); tmp[0]=tmp[i]=1; for(i

求杨辉三角的某一行，这次不用记录全部的三角，只要纪录上一行就可以了。 vector getRow(int rowIndex) { vector pre; for(int i=0;i<rowIndex+1;i++){ vector tmp(i+1); tmp[0]=tmp[i]=1;

从前往后找，找到一个和前一个数字不同的就放到前面，相同的话不予处理。 int removeDuplicates(vector& nums) { if(nums.size()==0) return 0; int len = 1; for(int i=1;i<nums.size();i++){

这道题就是看n里面有多少个5+5^2+5^3...... int trailingZeroes(int n) { if(n==0) return 0; int num = 0; if(n/5<5) return n/5; int tmp; while((tmp = n/5) != 0){

这题利用了set里面不能放重复元素的特性来解决class Solution {public: vector intersection(vector& nums1, vector& nums2) { set s; vector nums3; for (int i = 0;i<nums1.size();i++){

这个一分钟搞定。就是要对位运算有一定的了解乘2相当于整体二进制位左移一位，而且这种运算方式比直接乘要快。因此只要判断是奇数就加一，然后整体右移一位。class Solution {public: int hammingWeight(uint32_t n) { int count = 0; while(n){

注意几个点，不能是负数，不用额外的空间。思路就是让数字的第一个数和最后一个数比较。然后去掉头和尾。再继续。不用担心00002这样的情况，因为不影响计算。 bool isPalindrome(int x) { if (x<0) return false; if (x>=0&&x<10) return true;

这个看了一个别人的代码，写的很优美。 bool hasPathSum(TreeNode* root, int sum) { if(!root) return false; else if(!root->left&&!root->right&&root->val == sum) return true; else return hasPath

判断数独是不是正确的，就是判断每一行，每一列，每个小棋盘，有没有重复的。用三个二维数组纪录。有就置1.主要的是小棋盘序号的计算方法。行为i/3*3列为j/3小棋盘的序号为行加列。（参考了discuss里面最热的帖子）代码如下： bool isValidSudoku(vector>& board) { int board1[9][9] = {0}

求深度的变种，但不能单纯的选最短的那一条，要选有路的最短的那一条。int minDepth(TreeNode* root) { if(!root) return 0; else if(root->left&&root->right) return min(minDepth(root->left),minDepth(root->right))+1;

两个队列实现一个栈，核心思想就是压栈的时候，压入空的队列，然后把非空的队列的元素亚到后面去。 queue q1; queue q2; void push(int x) { if(q1.empty()&&q2.empty()){ q1.push(x); }else if(q2.empty()){

先算出两个链表的长度，让长的那个先走长度差的距离，再进行比较。本想先判断一下结尾，如果结尾不同那就肯定不同，但是速度变慢了，不知道哪里写的不好，就先不加了。 ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { int i = 0; int j = 0;

这题只要把各种情况考虑全了就可以。用栈实现。 bool isValid(string s) { stack st; for(int i = 0;i<s.size();i++){ if(s[i] == '(' || s[i] == '{' || s[i] == '['){ st.push(s[i])