链表面试题总结（一）

上一篇文章中简单地对单链表一些功能的实现进行说明，感兴趣的小伙伴可以戳链接看一下之前的博客——单链表的C语言实现。在我们面试中，单链表也是面试官比较感兴趣的地方。那么今天，我们就将单链表面试题总结一下。

常见的面试题目：

• 从尾到头打印单链表
• 逆置/反转单链表
• 删除一个无头单链表的非尾节点
• 在无头单链表的一个非头节点前插入一个节点
• 单链表实现约瑟夫环(JosephCircle)
• 单链表排序（冒泡排序）
• 查找单链表的中间节点，要求只能遍历一次链表
• 查找单链表的倒数第k个节点，要求只能遍历一次链表

从尾到头打印单链表

分析：最简单的方式就是找到最后一个节点，从后向前开始打印，鉴于这个特点，我们能想到之前学到的递归，一层一层找到最后一个元素，然后一直返回到最开始。

void PrintTailToHead(SListNode*& pHead)  //逆序打印
{
    if (pHead == NULL)
        return;
    else
    {
        PrintTailToHead(pHead->next);
        printf("%d ", pHead->data);
    }
    printf("\n");
}

逆置/反转单链表

分析：先创建一个newNode，然后通过访问pcur的第一个节点，进行尾插，移动newNode，让它始终是头节点，tmp总是保存当前节点的信息，让pcur一直指向下一个。重复这个过程，直到这个链表的最后一个节点被访问。

注意：一定要先保存当前节点的信息，pcur在指向下一个，要不然节点就找不到了！

void Reserve(SListNode*& pHead)   //逆置单链表
{
    assert(pHead);
    if (pHead->next == NULL)
        return;
    else
    {
        SListNode* pcur = pHead;
        SListNode* newNode = NULL;
        SListNode* tmp = pHead;
        while (pcur)
        {
            tmp = pcur;
            pcur = pcur->next;   //先保存在指向下一个
            tmp->next = newNode;
            newNode = tmp;
        }
        pHead = newNode;
    }
}

---

删除一个无头单链表的非尾节点

分析：既然是一个无头链表，那么我们就不能通过直接访问这种形式进行删除。找不到上一个，那么就找下一个，让tmp保存node后节点的信息，然后让改动node的值，让node指向tmp的下一个，此时删除tmp，也顺利完成题目的要求。

void DeleteNotTail(SListNode* Node)  //删除一个无头单链表的非尾节点
{
    assert(Node);
    SListNode* tmp =Node->next;
    Node->data = tmp->data;
    Node->next = tmp->next;
    free(tmp);
}

---

在无头单链表的一个非头节点前插入一个节点

分析：如果上面那个删除无头链表节点问题，你想清楚了，那么这道题对你来说也没什么悬念。思路是一样，只不过，这道题是先为node开辟一个节点，然后指向下一个，最后让插入节点的数据直接覆盖node的数据。

void InsertNotHead(SListNode* pos) //在无头单链表的非头节点插入一个节点
{
    assert(pos);
    DataType data= 7;   //插入数字7；
    SListNode* next = pos->next;
    SListNode* tmp = BuyNode(pos->data);
    pos->next = tmp;
    tmp->next = next;
    pos->data = data;
}

---

单链表实现约瑟夫环(JosephCircle)

约瑟夫环问题：约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3…n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。通常解决这类问题时我们把编号从0~n-1，最后[1] 结果+1即为原问题的解。

分析：这里对数据的删除还是先创建一个临时变量，然后通过修改当前节点的数据，释放临时变量存储的节点，以达到删除当前节点的目的。

SListNode* JosephCircle(SListNode* Node, int k)//单链表实现约瑟夫环
{
    assert(Node);
    SListNode* cur = Node;
    while (cur->next != cur)
    {
        int x = k;
        while (--x)
        {
            cur = cur->next;
            SListNode* tmp = cur->next;
            cur->data = tmp->data;
            cur->next = tmp->next;
            free(tmp);
        }
    }
    return cur;
}

---

单链表排序（冒泡排序）

分析：单链表的排序和数组的排序几乎没有一点区别，都是先比较大小，接着创建临时变量，然后交换数值，这里就不画图进行解释了。

void BubbleSort(SListNode* pHead)   //单链表排序（冒泡）
{
    SListNode* tail = NULL;

    while (tail != pHead)
    {
        SListNode* cur = pHead;
        SListNode* next = pHead->next;
        int flag = 0;
        do
        {
            if(cur->data > next->data)
            {
                DataType tmp = cur->data;
                cur->data = next->data;
                next->data = tmp;
                flag = 1;
            }
            cur = cur->next;
            next = next->next;
        } while (next != tail);
        tail = cur;
        if (flag ==0 )
            break;
    }
}

---

查找单链表的中间节点，要求只能遍历一次链表

分析：遍历一次查找某个节点，是链表里有名的快慢指针问题。通过两个指针行走的快慢不同，对链表进行访问，利用之间的位移差找到符合题目要求的答案。因为本题要求查找的是中间节点，所以fast每次走2步，slow每次走1步，当fast走到最后的时候，它们之间的位移差恰好是链表的一半。

SListNode* FindMidNode(SListNode* pHead)   //查找单链表的中间节点，要求只能遍历一次链表
{
    SListNode* fast, *slow;
    fast = slow = pHead;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }

    return slow;
}

---

查找单链表的倒数第k个节点，要求只能遍历一次链表
分析：这个题的思路和上一个题是一样的，只不过这次快指针要比慢指针先走k-1步，然后快慢指针同时向后移动，当快指针访问到最后一个节点的时候，慢指针恰好访问到倒数第k个。

SListNode* FindLastK(SListNode* pHead, int k)  //查找单链表倒数第K个节点，要求只能遍历一次链表
{
    SListNode* fast, *slow;
    fast = slow = pHead;
    while (k--)
    {
        fast = fast->next;
    }

    while (fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

总体来说，链表的面试题都是有一定规律的，只要找出规律，代码部分的实现并不是特别难。下一篇博客将会总结一些链表相交问题及带环问题的功能实现。