LeetCode笔记（链表中点和反转，旋转图形）

198. 打家劫舍 - easy

经典动态规划中选不选问题

//13.01
//13.06
class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty()) return 0;
        if(nums.size() == 1) return nums[0];
        //if(nums.size() == 2) return max(nums[0], nums[1]);

        vector<int> ans(nums.size(), 0);
        ans[0] = nums[0];
        ans[1] = max(nums[0], nums[1]);
        for(int i = 2; i < nums.size(); i++) {
            ans[i] = max(ans[i-1], ans[i-2]+nums[i]);
        }

        return ans.back();
    }
};

234. 回文链表* - easy

自己的方法比较复杂，先找到list的中点，从中间开始反转list，之后同时从头往中点遍历以及从末尾往中间遍历，若每次他们的val都相同则为回文链表，但用时长，虽然应该也是时间O(n)，空间O(1)

看完答案后发现我的思路是对的，一摸一样，而且代码也差不多，看来之所以慢是因为我的reverse是函数，函数调用花费了时间（这算是复习了找链表中点和反转链表）

//17.25
//17.49
class Solution {
    void reverse(ListNode* &head) {  //反转列表
        if(head == nullptr) return ;
        if(head->next == nullptr) return ;

        ListNode* pre = head;
        ListNode* cur = pre->next;
        ListNode* nex = cur->next;
        pre->next = nullptr;		//反转列表的最后一个指向nullptr
        while(cur != nullptr) {
            cur->next = pre;
            pre = cur;
            cur = nex;
            if(nex != nullptr) nex = nex->next;
        }
        head = pre;					//head成为反转列表的head
    }
public:
    bool isPalindrome(ListNode* head) {
        ListNode* slow = head, *fast = head;
        while(fast != nullptr) {	//找到列表的中点，用slow记录
            slow = slow->next;
            fast = fast->next;
            if(fast) fast = fast->next;
        }
        reverse(slow);				//从中点开始反转
        while(slow != nullptr && head != nullptr) {
            if(slow->val != head->val) return 0;
            else {
                slow = slow->next;
                head = head->next;
            }
        }
        return 1;
    }
};

141. 环形链表 - easy

一开始以为不仅要判断还要找出循环点，后来才发现只要判断即可，瞬间变简单了

//18.13
//18.20
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr) return 0;

        ListNode *slow, *fast;
        slow = fast = head;

        do{
            slow = slow->next;
            fast = fast->next;
            if(fast != nullptr) fast = fast->next;
        }while(fast != slow && fast != nullptr);

        if(nullptr == fast) return 0;
        else return 1;
    }
};

48. 旋转图像* - medium

没做出来，根据答案可以发现规律：转置（沿对角线交换）+镜像（反转数组）

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        for(int i = 0; i < matrix.size(); i++) {
            for(int k = 0; k < i; k++) {
                swap(matrix[i][k], matrix[k][i]);
            }
        }
        for(int i = 0; i < matrix.size(); i++) {
            for(int k = 0; k < matrix.size()/2; k++) {
                swap(matrix[i][k], matrix[i][matrix.size()-k-1]);
            }
        }
    }
};