LeetCode 2015.8.7 173,75,39,78,82,90,103

LeetCode 2015.8.7 173,75,39,78,82,90,103

173 Binary Search Tree Iterator
class BSTIterator {
public:
    stack<TreeNode*> s;
    BSTIterator(TreeNode *root) {
        while (root!=NULL)
        {
            s.push(root);
            root=root->left;
        }
    }

    /** @return whether we have a next smallest number */
    bool hasNext() {
        return (!s.empty());
    }

    /** @return the next smallest number */
    int next() {
        TreeNode* tmp=s.top();
        s.pop();
        TreeNode* tmp2=tmp->right;
        if (tmp2!=NULL)
        {
            s.push(tmp2);
            while (tmp2->left!=NULL)
            {
                s.push(tmp2->left);
                tmp2=tmp2->left;
            }
        }
        return tmp->val;
    }
};

75 Sort Colors
1.计数排序
class Solution {
public:
    void sortColors(vector<int>& nums) {
        int cnt[4]={0};
        for(int i=0;i<nums.size();i++)
            cnt[nums[i]]++;
        int n=-1;
        for(int i=0;i<=2;i++)
        {
            for(int j=1;j<=cnt[i];j++)
            {
                n++;
                nums[n]=i;
            }
        }
    }
};

2.平移插入
class Solution {
public:
    void sortColors(vector<int>& nums) {
        int zero=-1,one=-1,two=-1;
        int n=nums.size();
        for(int i=0;i<n;i++)
        {
            if (nums[i]==0)
            {
                nums[++two]=2;
                nums[++one]=1;
                nums[++zero]=0;
                continue;
            }
            if (nums[i]==1)
            {
                nums[++two]=2;
                nums[++one]=1;
                continue;
            }
            nums[++two]=2;
        }
    }
};

39 Combination Sum
1.有点冗余的回溯
class Solution {
public:
    vector<int> tmp;
    vector< vector<int> > ans;
    vector< vector<int> > combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        depthSearch(target,0,candidates,candidates.size());
        return ans;
    }
    void depthSearch(int left,int index,vector<int> c,int n)
    {
        if (left==0)
        {
            ans.push_back(tmp);
            return ;
        }
        if (index==n) return ;
        int d = left / c[index];
        for(int i=0;i<=d;i++)
        {
            for(int j=1;j<=i;j++)
                tmp.push_back(c[index]);
            depthSearch(left-c[index]*i,index+1,c,n);
            for(int j=1;j<=i;j++)
                tmp.pop_back();
        }
        return ;
    }
};

2.没有冗余的回溯
class Solution {
public:
    vector<int> tmp;
    vector< vector<int> > ans;
    vector< vector<int> > combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());
        depthSearch(target,candidates,0);
        return ans;
    }
    void depthSearch(int left,vector<int> c,int index)
    {
        if (left==0)
        {
            ans.push_back(tmp);
            return ;
        }
        for(int i=index;i<c.size();i++)
        {
            if (left<c[i]) break;
            tmp.push_back(c[i]);
            depthSearch(left-c[i],c,i);
            tmp.pop_back();
        }
        return ;
    }
};

78 Subsets
class Solution {
public:
    vector< vector<int> > ans;
    vector<int> tmp;
    vector< vector<int> > subsets(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        depthSearch(0,nums,nums.size());
        return ans;
    }
    void depthSearch(int index,vector<int>& nums,int n)
    {
        if (index==n)
        {
            ans.push_back(tmp);
            return ;
        }
        tmp.push_back(nums[index]);
        depthSearch(index+1,nums,n);
        tmp.pop_back();
        depthSearch(index+1,nums,n);
    }
};

82 Remove Duplicates from Sorted List II
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* h = new ListNode(0);
        h->next=head;
        ListNode* p = h;
        ListNode* q = p->next;
        bool flag;
        while (q!=NULL && q->next!=NULL)
        {
            flag = false;
            while (q->next!=NULL && q->val == q->next->val)
            {
                flag=true;
                ListNode* tmp = q->next;
                q->next=tmp->next;
                delete tmp;
            }
            if (flag)
            {
                p->next=q->next;
                ListNode* tmp = q;
                delete tmp;
                q=p->next;
            }
            else
            {
                p=p->next;
                q=p->next;
            }
        }
        return h->next;
    }
};

90 Subsets II
class Solution {
public:
    vector< vector<int> > ans;
    vector<int> num;
    vector<int> cnt;
    vector<int> tmp;
    int n;
    vector< vector<int> > subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        if (nums.size()==0)
        {
            ans.push_back(tmp);
            return ans;
        }
        num.push_back(nums[0]-1);
        cnt.push_back(0);
        n=0;
        for(int i=0;i<nums.size();i++)
        {
            if (nums[i]==num[n])
                cnt[n]++;
            else
            {
                num.push_back(nums[i]);
                cnt.push_back(1);
                n++;
            }
        }
        depthSearch(1);
        return ans;
    }
    void depthSearch(int index)
    {
        ans.push_back(tmp);
        for(int i=index;i<= n;i++)
        {
            if (cnt[i]==0) continue;
            tmp.push_back(num[i]);
            cnt[i]--;
            depthSearch(i);
            tmp.pop_back();
            cnt[i]++;
        }
        return ;
    }
};

103 Binary Tree Zigzag Level Order Traversal
class Solution {
public:
    vector< vector<int> > zigzagLevelOrder(TreeNode* root) {
        vector< vector<int> >ans;
        vector<int> tmp;
        if (root==NULL) return ans;
        vector< vector<TreeNode*> > mid;
        int flag = 1;
        mid.resize(2);
        mid[0].push_back(root);
        mid[1].push_back(root);
        tmp.push_back(root->val);
        ans.push_back(tmp);
        for(;;)
        {
            if (mid[flag].size()==0) break;
            int now = 1 - flag;
            mid[now].clear();
            tmp.clear();
            for(int i=0;i<mid[flag].size();i++)
            {
                TreeNode* p=mid[flag][i];
                if (p->left!=NULL) mid[now].push_back(p->left);
                if (p->right!=NULL) mid[now].push_back(p->right);
            }
            if (flag==1)
            {
                for(int i=mid[now].size()-1;i>=0;i--)
                    tmp.push_back(mid[now][i]->val);
            }
            else
            {
                for(int i=0;i<mid[now].size();i++)
                    tmp.push_back(mid[now][i]->val);
            }
            if (tmp.size()!=0) ans.push_back(tmp);
            flag = 1-flag;
        }
    }
};