C++ 刷题记录 No.1

704. Binary Search

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        int mid = (left + right) / 2;
        while (mid >= left && mid <= right) {
            if (nums[mid] == target) {
              return mid;
            } else if (nums[mid] < target) {
              left = mid + 1;
              mid = (left + right) / 2;
            } else { // nums[mid] > target
              right = mid - 1;
              mid = (left + right) / 2;
            }
          }
        if (nums[mid] == target) {
            return mid;
        } else {
            return -1;
        }  
    }
};

要点：循环终止之后考虑一下找不到的情况

206. Reversed Linked List

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return head;
        }
          ListNode* remained = head->next;
          ListNode* reversed = head;
          reversed->next = nullptr;
          while (remained != nullptr) {
            ListNode* tmp = remained;
            remained = remained->next;
            tmp->next = reversed;
            reversed = tmp;
          }
          return reversed;
    }
};

先判断考虑特殊情况，然后递归，注意两处顺序，循环内和初始化的指针赋值会改变node值，不要乱动。

NULL v.s. nullptr

#define NULL 0
//since C++11
#define NULL nullptr
##

160. Intersection of Two Linked Lists

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        int lenA = 0;
        ListNode *ptrA = headA;
        while (ptrA != nullptr) {
            ptrA = ptrA->next;
            lenA++;
        }
        int lenB = 0;
        ListNode *ptrB = headB;
        while (ptrB != nullptr) {
            ptrB = ptrB->next;
            lenB++;
        }
        if (lenA > lenB) {
            int d = lenA - lenB;
            while (d--) {
                headA = headA->next;
            }
        } else {
            int d = lenB - lenA;
            while (d--) {
                headB = headB->next;
            }
        }
        
        while (headA != nullptr) {
            if (headA == headB) {
                return headA;
            }
            headA = headA->next;
            headB = headB->next;
        }
        return nullptr;
    }
};

一次AC，理解题意，intersection意味着之后不会diverge

31. Next Permutation

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int k = nums.size() - 2;
        for (; k >= 0; k--) {
            if (nums[k] < nums[k+1]) {
                break;
            }
        }
        if (k < 0) {
            std::reverse(nums.begin(), nums.end());
        } else {
            int j = nums.size() - 1;
            for (; j > k; j--) {
                if (nums[j] > nums[k]) {
                    break;
                }
            }
            std::swap(nums[j], nums[k]);
            std::reverse(nums.begin() + k + 1, nums.end());
        }
    }
};

https://www.cplusplus.com/reference/algorithm/next_permutation/

225. Implement Stack using Queues

class MyStack {
public:
    queue<int>* q1;
    queue<int>* q2;
    MyStack() {
        q1 = new queue<int>();
        q2 = new queue<int>();
    }
    
    void swap_queues() {
        queue<int>* q3 = q1;
        q1 = q2;
        q2 = q3;
    }
    
    void push(int x) {
        q1->push(x);
    }
    
    int pop() {
        if (empty()) {
            return -1;
        }
        while (q1->size() > 1) {
            int ele = q1->front();
            q1->pop();
            q2->push(ele);
        }
        int value = q1->front();
        q1->pop();
        swap_queues();
        return value;
    }
    
    int top() {
        return q1->back();
    }
    
    bool empty() {
        return (q1->size() + q2->size() == 0);
    }
    
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */