Rrui的Leetcode刷题笔记（二）

54. 螺旋矩阵

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int>re;
        if(matrix.empty() || matrix[0].empty()) return re;
        int l=0, r=matrix[0].size()-1, up=0, low=matrix.size()-1;
        while(l<=r && up<=low){
            for(int j=l; j<=r; ++j)
                re.push_back(matrix[up][j]); 
            for(int i=up+1; i<=low; ++i)
                re.push_back(matrix[i][r]);
            for(int j=r-1; low>up && j>=l; --j)
                re.push_back(matrix[low][j]);
            for(int i=low-1; r>l && i>up; --i)
                re.push_back(matrix[i][l]);
            ++l,  --r, ++up, --low;
        }
        return re;
    }
};

55. 跳跃游戏

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int aa=0;
        for (int i = 0; i < nums.size(); ++i){
            aa = max(aa, nums[i] + i);
            if(aa<=i && i!=nums.size()-1) return false; 
        }
        return true;
    }
};

56. 合并区间

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    
    
    static bool cmp(Interval a, Interval b){
        if(a.start != b.start)
            return a.start<b.start;
        else
            return a.end<b.end;
    }

    vector<Interval> merge(vector<Interval>& intervals) {
        
      
        vector<Interval> a;
        
        if(intervals.size()==0)
            return a;
        
        intervals.push_back(Interval(INT_MAX,INT_MAX));          
        sort(intervals.begin(),intervals.end(),cmp);
        
        for(int i=0;i<intervals.size();i++)
        {
            if(intervals[i].end>=intervals[i+1].start)
            {
                intervals[i+1].start=intervals[i].start; 
                if(intervals[i].end>=intervals[i+1].end)
                    intervals[i+1].end=intervals[i].end;                    
            }
            else
                a.push_back(intervals[i]);            
        }
        
        return a;
  
    }
};

57. 插入区间

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    
    static bool cmp(Interval a, Interval b){
        if(a.start != b.start)
            return a.start<b.start;
        else
            return a.end<b.end;
    }

    vector<Interval> merge(vector<Interval>& intervals) {
        
      
        vector<Interval> a;
        
        if(intervals.size()==0)
            return a;
        
        intervals.push_back(Interval(INT_MAX,INT_MAX));          
        sort(intervals.begin(),intervals.end(),cmp);
        
        for(int i=0;i<intervals.size()-1;i++)
        {
            if(intervals[i].end>=intervals[i+1].start)
            {
                if(intervals[i].end==INT_MAX)
                    a.push_back(intervals[i]);                    
                intervals[i+1].start=intervals[i].start; 
                if(intervals[i].end>=intervals[i+1].end)
                    intervals[i+1].end=intervals[i].end;                    
            }
            else
                a.push_back(intervals[i]);            
        }
        
        return a;
    }
    
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        
        intervals.push_back(newInterval);

        return merge(intervals);      
    }
        
};

58. 最后一个单词的长度

扫描二维码关注公众号，回复： 3493675 查看本文章

class Solution {
public:
    int lengthOfLastWord(string s) {
        
        int a=0,k=0;
        
        for(int i=s.size()-1;i>=0;i--)
        {
            if(s[i]==' ')
            {
                if(a)
                    break;
                continue;                
            }
            else
            {
                a++;
            }
        }        
        return a;
    }
};

59. 螺旋矩阵 II

class Solution {
public:
  vector<vector<int> > generateMatrix(int n) {

  vector<vector<int> > matrix(n, vector<int>(n) );
  int u = 0, d = n - 1, l = 0, r = n - 1, k = 0;

  while (true) {
    // up
    for (int col = l; col <= r; col++) matrix[u][col] = ++k;
    if (++u > d) break;
    // right
    for (int row = u; row <= d; row++) matrix[row][r] = ++k;
    if (--r < l) break;
    // down
    for (int col = r; col >= l; col--) matrix[d][col] = ++k;
    if (--d < u) break;
    // left
    for (int row = d; row >= u; row--) matrix[row][l] = ++k;
    if (++l > r) break;
  }
  return matrix;
}
};

60. 第k个排列

class Solution {
public:
    
     void nextPermutation(string& nums) {
        
        int k=-1,p;
        
        for(int i=nums.size()-1;i>0;i--)
        {
            if(nums[i]>nums[i-1])  
            {
                k=i-1;
                break;
            }
        }
        
        if(k<0)
            reverse(nums.begin(), nums.end());        
        else{
            
            for(int i=nums.size()-1;i>0;i--)
            {
                if(nums[i]>nums[k])  
                {
                    p=i;
                    break;
                }
            }        

            swap(nums[p],nums[k]);

            reverse(nums.begin()+k+1, nums.end());            
        }  
    }  
    
    string getPermutation(int n, int k) {
        
        string a;
        
        vector<string> b;
        if(n==0)
            return a;
            
        int p=1;

        for(int i=1;i<n;i++)
        {
            p=10*p+(p%10+1);
        }
        
        a=to_string(p);
        
        for(int i=0;i<k-1;i++)
            nextPermutation(a);
        
        
        return a;      
    }
};

66. 加一

class Solution {
public:
    vector<int> plusOne(vector<int>& digits) {
        
        long long k=0,p=0,q=0;
        vector<int> a;
        
        int b=digits.size();
        
        digits[b-1]++;
        
        while(1)
        {
            if(digits[b-1-p]>9)
            {
                digits[b-1-p]=0;
                p++;
                if(b-1-p<0)
                {
                    digits.insert(digits.begin(),1);
                    break;
                }
                digits[b-1-p]++;
            }
            else
                break;
        }

        return digits;
    }
};

67. 二进制求和

class Solution {
public:
    string addBinary(string a, string b) {
        string ret;
        int la = a.length();
        int lb = b.length();
        int lmax = max(la, lb);
        int add = '0';
        for (int i = 0; i < lmax; i++) {
            char ca = la > i ? a[la-i-1] : '0';
            char cb = lb > i ? b[lb-i-1] : '0';
            char s = (ca == cb ? '0' : '1');
            char sj = (s == add ? '0' : '1');
            if (ca == '1' && cb == '1'
                    || s == '1' && add == '1') {
                add = '1';        
            } else {
                add = '0';
            }
            ret += sj;
        }
        if (add == '1') {
            ret += add;
        }
        reverse(ret.begin(), ret.end());
        return ret;
    }
};

69. x 的平方根

class Solution {
public:
    int mySqrt(int x) {
        for(long i = 0; ;i ++) {
            if(i*i > x) return i-1;
        }
    }
};

82. 删除排序链表中的重复元素 II

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        if (!head || !head->next) return head;
        
        ListNode *start = new ListNode(0);
        start->next = head;
        ListNode *pre = start;
        while (pre->next) {
            ListNode *cur = pre->next;
            while (cur->next && cur->next->val == cur->val) cur = cur->next;
            if (cur != pre->next) pre->next = cur->next;
            else pre = pre->next;
        }
        return start->next;
    }
};

83. 删除排序链表中的重复元素

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        
        ListNode* p=head;
        
        if(!p)
            return head;
        
        int k;
        k=p->val;
        while(p->next)
        {
            if(p->next->val==k)
                p->next=p->next->next;
            else
            {
                p=p->next;                
            }

            if(!p)
                break;
            k=p->val;            
        }
        return head;
    }
};

88. 合并两个有序数组

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        
        vector<int> nums3;
        nums1.insert(nums1.begin()+m,INT_MAX);
        nums2.insert(nums2.begin()+n,INT_MAX);        
        
        int p=0,q=0;
        for(int i=0;i<m+n;i++)
        {
            if(nums1[p]<nums2[q])
            {
                nums3.push_back(nums1[p]);
                p++;
            }            
            else{
                nums3.push_back(nums2[q]);
                q++;
            }   
        }
        
        nums1.swap(nums3);
    }
};

94. 二叉树的中序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        
        TreeNode* shu=root;
        stack<TreeNode*> sta;
        vector<int> a;
        
        while(shu||!sta.empty())
        {
            while(shu)
            {
                sta.push(shu);
                shu=shu->left; 
            }
            shu=sta.top();
            sta.pop();
            a.push_back(shu->val);
            shu=shu->right;
        }
        return a;   
    }
};

Rrui的Leetcode刷题笔记（二）

猜你喜欢