剑指 Offer第六天

剑指 Offer 24. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (!head || !head->next) return head;
        auto tail = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return tail;
    }
};

剑指 Offer 18. 删除链表的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if (!head) return head;
        auto dummy = new ListNode(-1), cur = dummy;
        cur ->next = head;
        while (cur->next->val != val) {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        return dummy->next;
    }
};

剑指 Offer 35. 复杂链表的复制

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    Node* copyRandomList(Node* head) {
        for (auto p = head; p; p = p->next->next) {
            auto cur = new Node(p->val);
            cur->next = p->next;
            p->next = cur;
        }

        auto dummy = new Node(-1), cur = dummy;
        for (auto p = head; p; p = p->next->next) {
            if (p->random)
                p->next->random = p->random->next;
        }

        for (auto p = head; p; p = p->next) {
            auto q = p->next;
            cur = cur->next = q;
            p->next = q->next;
        }
        return dummy->next;
    }
};

剑指 Offer 40. 最小的k个数

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        int n = arr.size();
        vector<int> res;
        priority_queue<int> q;
        for (auto& t : arr ) {
            if (q.size() < k) {
                q.push(t);
            }
            else if (q.size()) {
                if (q.top() > t) {
                    q.pop();
                    q.push(t);
                }
            }
        }
        while (q.size()) {
            res.push_back(q.top());
            q.pop();
        }
        return res;
    }
};

剑指 Offer 30. 包含min函数的栈

class MinStack {
public:
    stack<int> stk1, stk2;
    /** initialize your data structure here. */
    MinStack() {
        while (stk1.size()) stk1.pop();
        while (stk2.size()) stk2.pop();
    }
    
    void push(int x) {
        stk1.push(x);
        if (stk2.size() && stk2.top() < x) {
            stk2.push(stk2.top());
        }
        else stk2.push(x);
    }
    
    void pop() {
        stk1.pop();
        stk2.pop();
    }
    
    int top() {
        return stk1.top();
    }
    
    int min() {
        return stk2.top();
    }
};

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