C++面试篇之算法篇

问题1：反转单链表：

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* ReverseList(ListNode* head) {
        // write code here
     ListNode* pre = nullptr;
     while (head) { // 判断链表是否已经到结尾
         ListNode* t = head->next; // 保留下一个即将翻转的表头
         head->next = pre; // 将现在要翻转的节点的后继指向前一个节点 pre
         pre = head; // 现在的 P 成为下一个前继节点
         head = t; // p 成为下一个要翻转的节点
     }
     return pre;
    }
};

遍历一次链表，时间复杂度是 O(n)，空间复杂度是 O(1)。

问题2：合并两个有序链表：

递归法：

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead1 ListNode类 
     * @param pHead2 ListNode类 
     * @return ListNode类
     */
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        // write code here
        if (pHead1 == nullptr) return pHead2;
        if (pHead2 == nullptr) return pHead1;
    
        if (pHead1->val < pHead2->val) { // 先用较小的值的节点
            pHead1->next = Merge(pHead1->next, pHead2);
            return pHead1;
        } else {
            pHead2->next = Merge(pHead1, pHead2->next);
            return pHead2;
        }
    }
};

问题3：判断链表是否有环：

存储到hash表中；

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
#include <functional>
#include <map>
class Solution {
  public:
    bool hasCycle(ListNode* head) {
        map<ListNode*, int> mp; // 定义一个哈希表存储结点指针
        while (head) { // 不断遍历结点
            if (mp[head]) { //如果这个结点出现过
                return true;
            }
            // 如果没有出现过，那么标记为1,表示出现过了
            mp[head] = 1;
            head = head->next;
        }
        return false;
    }
};