LeetCode题解其一（题1~题5）

最新推荐文章于 2022-01-30 21:59:29 发布

LeafXR

最新推荐文章于 2022-01-30 21:59:29 发布

阅读量173

点赞数

本文链接：https://blog.csdn.net/deepsummer/article/details/39358451

版权

从这篇博客开始记录我做LeetCode每一题的思路，目标是记录完全部的150多道题

就按从上往下的顺序吧，每题都会用几句话说明思路和贴代码

1. Reverse Words in a String

Given an input string, reverse the string word by word.

For example,
Given s = "the sky is blue",
return "blue is sky the".

思路：字符串处理，主要是考查空格的处理吧，用stringstream会异常简单

class Solution {
public:
    void reverseWords(string &s) {
        stringstream ss(s);
        string word;
        vector<string> words;
        while(ss >> word) {
            words.push_back(word);
        }
        s = "";
        for(int i = words.size()-1; i >= 0; i--) {
            s += words[i];
            if(i) {
                s += " ";
            }
        }
    }
};

2. Evaluate Reverse Polish Notation

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

Valid operators are +, -, *, /. Each operand may be an integer or another expression.

Some examples:

  ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
  ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6

思路：逆波兰表达式求值，主要是考查栈的使用

class Solution {
public:
    int evalRPN(vector<string> &tokens) {
        stack<int> nums;
        int op1, op2;
        for(int i = 0; i < tokens.size(); i++) {
            if(tokens[i] == "+") {
                getOps(nums, op1, op2);
                nums.push(op1 + op2);
            }else if(tokens[i] == "-") {
                getOps(nums, op1, op2);
                nums.push(op1 - op2);
            }else if(tokens[i] == "*") {
                getOps(nums, op1, op2);
                nums.push(op1 * op2);
            }else if(tokens[i] == "/") {
                getOps(nums, op1, op2);
                nums.push(op1 / op2);
            }else {
                int num = atoi(tokens[i].c_str());
                nums.push(num);
            }
        }
        return nums.top();
    }
    
    void getOps(stack<int> &nums, int &op1, int &op2) {
        op2 = nums.top();
        nums.pop();
        op1 = nums.top();
        nums.pop();
    }
};

3. Max Points on a Line

Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

思路：暴力枚举的办法做的，不知道有没有效率更高的办法。
我用分子分母两个整型数来表示一个斜率，避免了判断两个浮点数相等的精度问题。另外比较两个斜率的时候需要特判垂直y轴的情况。

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
 
 struct Slope {
    int x;
    int y;
    Slope(int a, int b) : x(a), y(b) {}
        
    friend bool operator<(const Slope& p1, const Slope& p2) {
        if(p2.y == 0) {
            return p1.y != 0;
        }
        if(p1.y == 0) {
            return false;
        }
        return p1.x * p2.y < p2.x * p1.y;
    }
        
    bool operator==(const Slope& other) {
        if(y == 0 || other.y == 0) {
            return y == 0 && other.y == 0;
        }
        return x * other.y == other.x * y;
    }
};
    
bool cmp(const pair<Slope, int> &p1, const pair<Slope, int> &p2) {
	return p1.second < p2.second;
}

bool equal(const Point &p1, const Point &p2) {
    return p1.x == p2.x && p1.y == p2.y;
}
    
 
class Solution {
public:
    int maxPoints(vector<Point> &points) {
        int maxNum = 0;
        for(int i = 0; i < points.size(); i++) {
            map<Slope, int> slopeCount;
            int num = 0;
            for(int j = 0; j < points.size(); j++) {
                if(equal(points[i], points[j])) {
                    num++;
                    continue;
                }
                Slope slope(points[i].x - points[j].x, points[i].y - points[j].y);
                map<Slope, int>::iterator it = slopeCount.find(slope);
                if( it != slopeCount.end()) {
                    it->second = it->second + 1;
                }else {
                    slopeCount[slope] = 1;
                }
            }
            num = num + max_element(slopeCount.begin(), slopeCount.end(), cmp)->second;
            if(num > maxNum) {
                maxNum = num;
            }
        }
        return maxNum;
    }
};

4. Sort List

Sort a linked list in O(n log n) time using constant space complexity.

思路：时间复杂度为O(n log n)，空间复杂度为O(1)的链表排序。使用的是stl里list的sort算法。算法的思想是：建立一些桶来保存一些有序的子链表，第一个桶的链表要么为空，要么只有一个元素，第二个桶的链表要么为空，要么只有两个元素……第N个桶的链表要么为空，要么只有2^(N-1)个元素。对原来链表的每一个元素，先将其插入第一个桶，如果桶满了就把第一个桶的链表往后传，如果第二个桶为空，那么链表就落在第二个桶，否则就将第一个桶的链表和第二桶的链表进行归并，对后面的桶重复调用这个过程……语言表达有点拗口，直接看代码可能还易懂一点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *sortList(ListNode *head) {
        ListNode* buckets[64];
        memset(buckets, 0, sizeof(ListNode*)*64);
        ListNode* sorted = NULL;
        int nBuckets = 1;
        while(head) {
            int i = 0;
            sorted = head;
            head = head->next;
            sorted->next = NULL;
            while(NULL != buckets[i]) {
                merge(sorted, buckets[i++]);
            }
            if(i >= nBuckets) {
                nBuckets++;
            }
            buckets[i] = sorted;
        }
        sorted = buckets[0];
        for(int i = 1; i < nBuckets; i++) {
            if(buckets[i]) {
                merge(sorted, buckets[i]);
            }
        }
        return sorted;
    }
    
    void merge(ListNode* &head1, ListNode* &head2) {
        if(NULL == head1 || NULL == head2) {
            if(head2) {
                swap(head1, head2);
            }
            return;
        }
        ListNode* resHead = NULL; 
        ListNode* resTail = NULL;
        while(head1 && head2) {
            ListNode* smaller = NULL;
            if(head1->val <= head2->val) {
                smaller = head1;
                head1 = head1->next;
            }else {
                smaller = head2;
                head2 = head2->next;
            }
            
            if(resHead) {
                resTail->next = smaller;
                resTail = resTail->next;
            }else {
                resTail = resHead = smaller;
            }
        }
        if(head1) {
            resTail->next = head1;
        }else {
            resTail->next = head2;
        }
        head1 = resHead;
        head2 = NULL;
    }
};

5. Insertion Sort List

Sort a linked list using insertion sort.

思路：链表的插入排序，没啥好说的，面试中要问到的话估计也是考查链表操作吧。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *insertionSortList(ListNode *head) {
        ListNode* resHead = NULL;
        while(head) {
            ListNode* node2Insert = head;
            head = head->next;
            ListNode* postNode = NULL;
            ListNode* curNode = resHead;
            while(curNode != NULL && curNode->val < node2Insert->val) {
                postNode = curNode;
                curNode = curNode->next;
            }
            if(postNode) {
                postNode->next = node2Insert;
            }else {
                resHead = node2Insert;
            }
            node2Insert->next = curNode;
        }
        return resHead;
    }
};