用两个栈实现队列、反转链表、包含min函数的栈

• 剑指 Offer 09. 用两个栈实现队列

class CQueue {
public:
    CQueue() {

    }
    
    void appendTail(int value) {
        a.push(value);
    }
    
    int deleteHead() {
        if(a.empty())
        {
            return -1;
        }
        else
        {
            while(!a.empty())
            {
                b.push(a.top());
                a.pop();
            }
            int temp = b.top();
            b.pop();
            while(!b.empty())
            {
                a.push(b.top());
                b.pop();
            }
            return temp;
        }
    }

    stack<int> a, b;
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

构造函数空实现。起初看不懂示例，其实跟第一行输入完全没有关系，仅仅只是函数的调用。构造和入栈的操作没有返回值，所以给出的示例都是null。
关键是理解两个栈是如何实现队列的输入输入的。根据栈先入后出、队列先入先出的特点
两次的栈操作就相当于了先入先出，需要注意的是：每次取出完一个数据之后，就需要将b栈再重新压回a栈

• 反转链表

辅助栈法

/**
 * 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) {
        stack<int> s;
        ListNode* first = head;
        ListNode* p = head;
        while(head != nullptr)
        {
            s.push(head->val);
            head = head->next;
        }
        while(p != nullptr)
        {
            p->val = s.top();
            s.pop();
            p = p->next;
        }
        return first;
    }
};

双指针

/**
 * 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) {
        ListNode* cur = head;
        ListNode* pre = nullptr;

        while(cur != nullptr)
        {
            ListNode* tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
};

旨在改变next的方向

• 包含min函数的栈

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {

    }
    
    void push(int x) {
        a.push(x);
        if(b.empty() || b.top() >= x)
        {
            b.push(x);
        }
    }
    
    void pop() {

        if(a.top() == b.top())
        {
            b.pop();
        }
        a.pop();
    }
    
    int top() {
        return a.top();
    }
    
    int min() {
        return b.top();
    }

    stack<int> a, b;
};

/**
 * 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();
 */

这里最开始误以为是需要自己定义一个栈，结果并不是，在min函数中出现了问题：使用冒泡排序让时间超时了。此题方法是在类中使用两个栈，a记录传入的数据，b记录更新的最小值。当传入新数据比当前栈顶元素更小时，就将其压入b栈。当出栈时，出栈元素是最小元素a，b栈都需要出栈，此时b栈顶元素更新，最小值也跟着变化

• 复杂链表的复制

/*
// 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) {
        if(head == nullptr)
        {
            return nullptr;
        }

        unordered_map<Node*, Node*> m;
        Node* cur = head;
        while(cur != nullptr)
        {
            m[cur] = new Node(cur->val);
            cur = cur->next;
        }

        cur = head;

        while(cur != nullptr)
        {
            m[cur]->next = m[cur->next];
            m[cur]->random = m[cur->random];
            cur = cur->next;
        }

        return m[head];
    }
};

该方法使用了哈希表。看似简单，但random指针给你留下一个下马威。没有random仅使用遍历就可以将链表进行复制，本题难点： 在复制链表的过程中构建新链表各节点的 random 引用指向。哈希表正是解决了这一个问题。
首先看Node类里多了Node的构造函数，需要充分利用起来。建立一个哈希表 unordered_map<Node*, Node*> m;键值和key值都为Node*类型非常关键，这排除了val值相同的情况。
第一遍遍历，对于每个节点 cur，创建一个新节点，值和 cur 相同(构造函数体现了出来)，并将新节点存入哈希表 map 中，建立原节点到新节点的映射关系。
第二遍遍历，通过哈希表建立的原节点和新结点的映射关系给next和random赋值，重点在于理解第二个循环
最后怎么理解return m[head];—>map[head] 表示原链表的头节点 head 在哈希表中对应的新链表节点。