第二十九篇，C++面经之手写代码（三）

这篇主要写链表，链表也是手写代码面试的常出题目。

〇、节点定义

struct stNode // 链表节点
{
    int num;
    stNode* next;
};

以stNode结构体作为本篇题目中涉及到的链表节点的通用定义。

一、反转单链表

struct stNode* reverse(struct stNode* head) // 反转单链表
{
    struct stNode* pPre = nullptr;
    struct stNode* pCur = head;
    struct stNode* pNext = nullptr;
    while (pCur != nullptr)
    {
        pNext = pCur->next;
        pCur->next = pPre;
        pPre = pCur;
        pCur = pNext;
    }

    return pPre;
}

pre、current、next，这几个指针几乎是链表操作中的必备，还有head。
还有对双向链表的反转，笔者上学时就对链表避之唯恐不及，面试又没遇到双链表的题，所以干脆就不写。。。

二、判断链表中是否有环

bool checkLoop(struct stNode* head) // 快慢指针判断单链表中是否有环
{
    struct stNode* pSlow = head;
    struct stNode* pFast = head;
    while (pFast != nullptr && pFast->next != nullptr)
    {
        pSlow = pSlow->next;
        pFast = pFast->next->next;
        if (pSlow == pFast)
            return true;
    }
    return false;
}

这个也是对单链表的操作，印象中这个题不是面试遇到，好像是牛客刷题刷到的，感觉还挺有意思。
它是用一快一慢两个指针来检查有没有环，思路也很巧妙，一快一慢两个指针各自往前遍历，如果有环，那快指针必然在前进一定步数后绕到慢指针后面二者重新相遇。

三、删除链表中连续重复节点

删除单链表中重复节点，无保留；不需考虑被删除节点的delete问题
e.g.：1->1->2->3->3->4，执行后得2->4
stNode* deleteDuplication(stNode* pHead)
{
    stNode* pre, * last, * res;
    pre = new stNode();
    res = pre;
    pre->next = pHead;
    last = pHead;
    while (last != nullptr && last->next != nullptr)
    {
        if (last->num == last->next->num)
        {
            // 这是一个重复节点
            stNode* tmp = last;
            while (tmp != nullptr && tmp->num == last->num)
                tmp = tmp->next;
            // tmp是第一个不重复的节点
            pre->next = tmp;
            last = tmp;
        }
        else
        {
            // 如果不重复，则两个指针齐头并进
            pre = last;
            last = last->next;
        }
    }
    return res->next;
}

这道题是这样的，它不是要求删除所有重复的，而是连续重复的，比如1->2->3->3->4中3有重复且连续，那么把这两个3删除；再比如1->2->3->4->3中3有重复，但不是连续节点，不删除。
内外两个循环，外层循环用于遍历；内层循环用于找到连续重复节点后，确定连续重复节点的个数。
链表类的面试题往往重点考察思路，对内存泄漏等问题直接忽略，比如这道题中删除操作只要求转移指针指向，被删除的节点不要求delete释放内存，所以做这种题时把精力集中在实现主要需求上即可。

四、合并两个有序链表

第一篇中写了一道合并两个有序数组的问题，这一篇合并两个有序链表。

stNode* mergeTwoSortedList(stNode* list1, stNode* list2)
{
    if (list1 == nullptr || list2 == nullptr)
    {
        return (list1 == nullptr) ? list2 : list1;
    }

    stNode* pMove = new stNode();//move指针是每次后移的
    stNode* head = pMove;//需要确定好一个不变的头结点，然后返回这个头结点的next地址，才能返回完成的链表

    while (list1 != nullptr && list2 != nullptr)
    {
        if (list1->num <= list2->num)
        {
            pMove->next = list1;//这里只是确定好move->next是哪个结点，move还没有指向这个结点
            list1 = list1->next;
        }
        else
        {
            pMove->next = list2;
            list2 = list2->next;
        }
        pMove = pMove->next;//move指向这个结点
    }

    pMove->next = (list1 == nullptr) ? list2 : list1;//遇到一个为空后，哪个不为空就next指向哪一个

    return head->next;
}

数组是两相比较后放入某一位置，链表是两相比较后改变next指向；
同数组一样的，若一方已遍历完而另一方还有，需继续指向另一方剩余部分的首个节点。

五、移除链表中指定元素

我遇到的问题是移除链表中倒数第N个节点。

stNode* removeNthFromEnd(stNode* head, int n) 
{
    // write code here
    stNode* pre = new stNode();
    pre->next = head;
    stNode* target = pre;
    stNode* move = head;
    int count = 1;

    while (count != n)
    {
        move = move->next;
        count++;
    }

    while (move->next != nullptr)
    {
        move = move->next;
        target = target->next;
    }

    stNode* tmp = target->next;
    target->next = target->next->next;
    tmp->next = nullptr;

    return pre->next;
}

很是抱歉，我写的代码是移除正数第N个，因为天生对链表的恐惧，当时一慌就硬是没有倒数的思路，只得写了这个给面试官看，然后讨论了一下思路，呃。。。

六、题目见图，答案见代码

这道题做的时候用的链表解法，我当时猜出题人也是想让用链表的思路；事后自己又琢磨了数组解法，首先贴上链表解法。

	const int LIGHT_SIZE = 180; // 为方便测试及更优雅的设计，做个灯数目的常量

    stNode* pHead = new stNode;
    pHead->num = 0;
    pHead->next = nullptr;
    stNode* pPerm = pHead;

    for (int i=1; i<LIGHT_SIZE; i++)
    {
        stNode* tmp = new stNode;
        tmp->num = i*2;
        tmp->next = nullptr;

        pHead->next = tmp;
        pHead = pHead->next;
    }
    pHead->next = pPerm;
    // 至此为构造链表的过程，此时的pHead实际上指向的是“末尾”节点，pHead->next是“头”节点

    int n = 0;
    int count = 0;
    std::cout<<"input n:"<<std::endl;
    std::cin>>n;
    // 输入题目中的n

    stNode* pDelete = nullptr; // 用来释放删除节点的内存
    while (pHead->next != pHead) // 由于是有环结构，所以不能判空而应判自等
    {
        count++;
        if (count == n) // 灭灯
        {
            pDelete = pHead->next;
            pHead->next = pHead->next->next;
            delete pDelete;
            pDelete = nullptr;
            count = 0;
        }
        else // 计数中
        {
            pHead = pHead->next;
        }
    }

    std::cout<<pHead->num<<std::endl; // 输出结果

    delete pHead;
    pHead = nullptr;
    pPerm = nullptr;

下面是数组解法：

	int nLights[LIGHT_SIZE] = {0};
    int i = 0;
    for (auto& light : nLights)
    {
        light = i * 2;
        i++;
    }
    // 至此为数组法构造环形灯的过程

    i = 0;
    count = LIGHT_SIZE;
    int nn = 0;
    while (count != 1)
    {
        while (nLights[i] == -1) // 跳过已熄灭的灯
        {
            i++;
            i %= LIGHT_SIZE; // 求模操作是为了达到环形遍历的效果并防止数组越界
        }

        nn++;
        if (nn == n) // 计数满、灭灯
        {
            nLights[i] = -1;
            count--;
            nn = 0;
        }

        i++; // 计数未满，不灭灯，下一个
        i %= LIGHT_SIZE;
    }

// 由于数组不像链表紧密相连的结构，灭了最后一个灯后并不能直接知道剩余灯的位置
// 所以需要再遍历查找一次
    for (i=0; i<LIGHT_SIZE; i++)
        if (nLights[i] != -1)
            break;
    std::cout<<nLights[i]<<std::endl; // 输出结果

关于数组解法，又又想到了一招，即参考某一篇blog里数组元素查找的移位方法也可以实现，但可能效率较低因为会有大量的交换移位操作。
这个题挺好的。