LeetCode 2015.7.21-2015.7.24 144,141,136,137,129,22,238,122,121,24

LeetCode 2015.7.21-2015.7.24 144,141,136,137,129,22,238,122,121,24

144 Binary Tree Preorder Traversal 2015.7.21
class Solution {
public:
    vector<int> ans;
    vector<int> preorderTraversal(TreeNode* root) {
        ans.clear();
        preorder(root);
        return ans;
    }
    void preorder(TreeNode* root) {
        if (root==NULL) return;
        ans.push_back(root->val);
        if (root->left!=NULL) preorder(root->left);
        if (root->right!=NULL) preorder(root->right);
    }

};

141 Linked List Cycle及相关问题详细描述 2015.7.21
后来找到了复杂度O(n)的方法，使用两个指针slow,fast。两个指针都从表头开始走，slow每次走一步，fast每次走两步，如果fast遇到null，则说明没有环，返回false；如果slow==fast，说明有环，并且此时fast超了slow一圈，返回true。
为什么有环的情况下二者一定会相遇呢？因为fast先进入环，在slow进入之后，如果把slow看作在前面，fast在后面每次循环都向slow靠近1，所以一定会相遇，而不会出现fast直接跳过slow的情况。
扩展问题
在网上搜集了一下这个问题相关的一些问题，思路开阔了不少，总结如下：
1. 环的长度是多少？
2. 如何找到环中第一个节点（即Linked List Cycle II）？
3. 如何将有环的链表变成单链表（解除环）？
4. 如何判断两个单链表是否有交点？如何找到第一个相交的节点？
首先我们看下面这张图：
 
设：链表头是X，环的第一个节点是Y，slow和fast第一次的交点是Z。各段的长度分别是a,b,c，如图所示。环的长度是L。slow和fast的速度分别是qs,qf。
下面我们来挨个问题分析。
1. 方法一（网上都是这个答案）：
第一次相遇后，让slow,fast继续走，记录到下次相遇时循环了几次。因为当fast第二次到达Z点时，fast走了一圈，slow走了半圈，而当fast第三次到达Z点时，fast走了两圈，slow走了一圈，正好还在Z点相遇。
方法二：
第一次相遇后，让fast停着不走了，slow继续走，记录到下次相遇时循环了几次。
方法三（最简单）：
第一次相遇时slow走过的距离：a+b，fast走过的距离：a+b+c+b。
因为fast的速度是slow的两倍，所以fast走的距离是slow的两倍，有 2(a+b) = a+b+c+b，可以得到a=c（这个结论很重要！）。
我们发现L=b+c=a+b，也就是说，从一开始到二者第一次相遇，循环的次数就等于环的长度。
2. 我们已经得到了结论a=c，那么让两个指针分别从X和Z开始走，每次走一步，那么正好会在Y相遇！也就是环的第一个节点。
3. 在上一个问题的最后，将c段中Y点之前的那个节点与Y的链接切断即可。
4. 如何判断两个单链表是否有交点？先判断两个链表是否有环，如果一个有环一个没环，肯定不相交；如果两个都没有环，判断两个列表的尾部是否相等；如果两个都有环，判断一个链表上的Z点是否在另一个链表上。

136 Single Number 2015.7.22
1. 位运算
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        if (nums.size()==0) return 0;
        int ans = 0;
        for(int i=0;i<nums.size();i++)
            ans=ans ^ nums[i];
        return ans;
    }
};



2. 哈希
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int maxpos = -INT_MAX,maxneg= INT_MAX;
        for(int i=0;i<nums.size();i++)
        {
            if (nums[i]>=0 && nums[i]>maxpos) maxpos=nums[i];
            if (nums[i]<0 && nums[i]<maxneg) maxneg=nums[i];
        }
        if (maxneg==INT_MAX) maxneg=1;
        else maxneg=abs(maxneg);
        if (maxpos==-INT_MAX) maxpos=1;
        vector<int> pos;
        vector<int> neg;
        pos.clear();
        neg.clear();
        pos.resize(maxpos+1);
        neg.resize(maxneg+1);
        for(int i=0;i<nums.size();i++)
        {
            if (nums[i]>=0)
                pos[nums[i]]++;
            else
                neg[abs(nums[i])]++;
        }
        for(int i=0;i<nums.size();i++)
        {
            if (nums[i]>=0)
            {
                if (pos[nums[i]]==1) return nums[i];
            }
            else
            {
                if (neg[abs(nums[i])]==1) return nums[i];
            }
        }
    }
};

137 Single Number II 2015.7.23
class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int one, two, three;
        one = two = three = 0;
        for(int i=0;i<nums.size();i++)
        {
            three = two & nums[i];
            two = two | (one & nums[i]);
            one = one | nums[i];
            one = one & ~three;
            two = two & ~three;
        }
        return one;        
    }
};

129 Sum Root to Leaf Numbers 2015.7.23
class Solution {
public:
    int ans = 0;
    int sumNumbers(TreeNode* root) {
        if (root==NULL) return 0;
        depthSearch(root,0);
        return ans;
    }
    void depthSearch(TreeNode* root, int number)
    {
        number = number * 10 +root->val;
        if (root->left == NULL && root->right == NULL)
        {
            ans += number;
            return ;
        }
        if (root->left!=NULL) depthSearch(root->left,number);
        if (root->right!=NULL) depthSearch(root->right,number);
    }
};

22 Generate Parentheses 2015.7.23
1. 方法一： 深搜
class Solution {
public:
    vector<string> ans;
    vector<string> generateParenthesis(int n) {
        ans.clear();
        depthsearch("",n,n);
        return ans;
    }
    bool justify(string str)
    {
        stack<char> s;
        while (!s.empty()) s.pop();
        for(int i=0;i<str.size();i++)
        {
            if (str[i]=='(') s.push(str[i]);
            else
            {
                if (s.empty()) return false;
                if (s.top()=='(' ) s.pop();
                else return false;
            }
        }
        if (s.empty()) return true; else return false;
    }

    void depthsearch(string str,int left,int right)
    {
        if (left==0 && right==0)
        {
            if (justify(str)) ans.push_back(str);
            return ;
        }
        if (left>0) depthsearch(str+'(',left-1,right);
        if (right>0) depthsearch(str+')',left,right-1);
    }
};

2.方法二：递推

238 Product of Array Except Self 2015.7.24
class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> ans,left,right;
        ans.resize(nums.size());
        left.resize(nums.size()+5);
        right.resize(nums.size()+5);
        left[0] = 1;
        right[nums.size()+1] = 1;
        for(int i=0;i<nums.size();i++)
            left[i+1] = left[i] * nums[i];
        for(int i=nums.size()-1;i>=0;i--)
            right[i+1] = right[i+2] * nums[i];
        for(int i=0;i<nums.size();i++)
            ans[i] = left[i]*right[i+2];
        return ans;
    }
};

122 Best Time to Buy and Sell Stock II 2015.7.24
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int ans = 0;
        for(int i=1;i<prices.size();i++)
        {
            if (prices[i]-prices[i-1]>0)
                ans += prices[i]-prices[i-1];
        }
        return ans;
    }
};

121 Best Time to Buy and Sell Stock 2015.7.24
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size()==NULL) return 0;
        int minprice = INT_MAX;
        int ans = -INT_MAX;
        for(int i=0;i<prices.size();i++)
        {
            int tmp = prices[i] - minprice;
            if (tmp > ans) ans = tmp;
            if (prices[i]<minprice)
                minprice=prices[i];
        }
        if (ans<0) return 0;
        else return ans;
    }
};

24 Swap Nodes in Pairs 2015.7.24
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == NULL) return NULL;
        ListNode* k=new ListNode(0);
        k->next=head;
        ListNode* tmphead=head->next;
        ListNode* p = head;
        while (p!=NULL && p->next!=NULL)
        {
            ListNode* q = p->next;
            p->next = q->next;
            q->next = p;
            k->next=q;
            k = p;
            p=p->next;
        }
        if (tmphead!=NULL) return tmphead;
        else return head;
    }
};