C语言中的单链表面试题----基础

题目总览

1. 从尾到头打印单链表
2. 删除一个无头单链表的非尾节点
3. 在无头单链表的一个节点前插入一个节点
4. 单链表实现约瑟夫环
5. 逆置/反转单链表
6. 单链表排序（冒泡排序&快速排序）
7. 合并两个有序链表,合并后依然有序
8. 查找单链表的中间节点，要求只能遍历一次链表
9. 查找单链表的倒数第n个节点，要求只能遍历一次链表

思路及代码

从尾到头打印单链表

递归法，若当前节点不为空，在打印当前节点前打印上一个节点。

void ConversePrint(ListNode* pList)
{
    if (pList != NULL)
    {
        ConversePrint(pList->next);
        printf("%d ", pList->data);
    }
}
 
 
1
2
3
4
5
6
7
8
 
 
1
2
3
4
5
6
7
8

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

将当前节点的内容改为下个节点的内容，释放下个节点，让当前节点指向下下个节点。

void popNode(ListNode* pList)
{
    if (pList != NULL)
    {
        ListNode* tmp = pList->next;
        pList->data = pList->next->data;
        pList->next = pList->next->next;
        free(tmp);
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
 
 
1
2
3
4
5
6
7
8
9
10

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

新建一个节点保存当前节点的内容，并指向下一个节点。 
将当前节点改为插入的内容，指向新节点。

void InsertBefore(ListNode* pList, DataType x)
{
    assert(pList);
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = pList->data;
    newNode->next = pList->next;
    pList->next = newNode;
    pList->data = x;
}
 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

单链表实现约瑟夫环

• 接收一个环形链表的头指针地址，将头指针改为剩下的最后一个节点。
• 处理空链表。
• 用一个节点指针指向头节点，当前节点的下一节点不是当前节点（节点数大于一），循环，当前节点为第一个节点，走 n-1 步，指向第n个节点，删除当前节点。
• 将初始头指针赋值最后节点。

void Joseph(ListNode** ppList, int n)
{
    assert(ppList);
    if (*ppList == NULL)return;
    ListNode* pList = *ppList;
    while (pList->next != pList)
    {
        int i;
        for (i = 1; i < n; i++)
            pList = pList->next;
        popNode(pList);
    }
    *ppList = pList;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

逆置/反转单链表

• 头插法，建立新链表，用 cur 指向旧链表头结点。
• 循环，用 tmp 保存要拿下来的原链表头结点 cur， cur 指向下一节点，将 tmp 放到新链表的头部（tmp的下一节点指向新链表头结点，再将新链表的头结点改为 tmp），直到 cur 为 NULL。
• 将原链表头指针改为新链表。

void ReverseList(ListNode** ppList)
{
    assert(ppList);

    ListNode* newList = NULL;
    ListNode* cur = *ppList;
    while (cur)
    {
        ListNode* tmp = cur;
        cur = cur->next;
        tmp->next = newList;
        newList = tmp;
    }
    *ppList = newList;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

单链表排序（冒泡排序）

• 接收一个普通单链表，处理空链表和只有一个节点的情况。
• 用 tail 指示一次冒泡的终点，第一次要全排，赋值为NULL。
• 循环冒泡比较，每次比较（交换）后，cur 和 next 都指向它们的下一个节点，直到 next == tail。交换中，修改交换标记 exchange。
• 外层循环，用 cur 表示比较的第一个节点，用 next 表示比较的下一个节点，exchange 记录是否交换，一趟比较没有交换，说明已排好，直接返回。每趟比较之后，此次最后一个值已经为最大，tail 前移一个节点。

void ListBubbleSort(ListNode* pList)
{
    if (pList == NULL || pList->next == NULL)return;

    ListNode* tail = NULL;
    while (tail != pList)
    {
        ListNode* cur = pList;
        ListNode* next = pList->next;
        int exchange = 0;
        while (next != tail)
        {
            if (cur->data > next->data)
            {
                DataType num = cur->data;
                cur->data = next->data;
                next->data = num;
                exchange = 1;
            }
            cur = next;
            next = next->next;
        }
        if (exchange == 0)
            return;
        tail = cur;
    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

合并两个有序链表,合并后依然有序

方法一 
- 新链表段接法 
- 接收两个链表指针，处理有空链表的情况。 
- 创建新链表头指针，指向两链表头节内值点较小的的节点。 
- 循环，节点小的指针后移，直到节点下一节点大于另一指针或节点为空，tmp 保存下一节点，当前节点指向另一指针，当前指针赋值为 tmp，如果当前指针为 NULL，说明合并完成，结束循环。 
- 返回新链表头指针。 
- 可以总是让 p1 指向小的，p2 指向大的，循环挪 p1，接完后再把小的给 p1，大的给 p2。可以不用比较。（原方法 else 是复制 if 后，1 和 2 换，其实更简单，看起来多） 
思路图 

ListNode* MergeList(ListNode* List1, ListNode* List2)
{
    if (List1 == NULL)return List2;
    if (List2 == NULL)return List1;

    ListNode* newList = List1->data <= List2->data ? List1 : List2;
    while (true)
    {
        if(List1->data <= List2->data)
        {
            while (List1->next != NULL && List1->next->data <= List2->data)
            {
                List1 = List1->next;
            }
            ListNode* tmp = List1->next;
            List1->next = List2;
            List1 = tmp;
            if (List1 == NULL)
                break;
        }
        else
        {
            while (List2->next != NULL && List2->next->data <= List1->data)
            {
                List2 = List2->next;
            }
            ListNode* tmp = List2->next;
            List2->next = List1;
            List2 = tmp;
            if (List2 == NULL)
                break;
        }
    }
    return newList;
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

方法二 
- 新链单节点表尾插法 
- 新建 newList = NULL, 循环，每次比较两指针内容，保存小的节点，小节点指针后移，小节点尾接到 newList。 
- 如果有一个指针为 NULL，另一个指针尾接到 newList，返回 newList。 
方法三 
- 介于上两个方法之间，以头结点小的为 newList，另一个链表每次拿下一个节点接到 newList 的合适位置，直到其中一个指针为空。

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

• 快慢指针法，初始快指针、慢指针都是头指针。
• 循环，如果快指针能走两步（快指针的下一个节点和下下一个节点不为空），快指针走两步，慢指针走一步。
• 返回慢指针。

ListNode* FindMidNode(ListNode* pList)//mid = total>>1
{
    ListNode* fast = pList;
    while (fast->next != NULL && fast->next->next != NULL)
    {
        fast = fast->next->next;
        pList = pList->next;
    }
    return pList;
}
 
 
1
2
3
4
5
6
7
8
9
10
 
 
1
2
3
4
5
6
7
8
9
10

查找单链表的倒数第n个节点，要求只能遍历一次链表

• 当节点数少于n时，NULL。
• 快慢指针法，创建返回指针 ret ，快指针先走 n-1 步（此时 ret 为快指针的倒数第 n 个节点）或到 NULL 为止。
• 循环，快指针的下一个节点不为空，快指针和 ret 都向后走一步。
• 返回返回指针。

ListNode* FindFromLast(ListNode* pList, int n)
{
    ListNode* ret = pList;
    while (--n)
    {
        if(ret == NULL)return NULL;
        pList = pList->next;
    }
    while (pList->next != NULL)
    {
        ret = ret->next;
        pList = pList->next;
    }
    return ret;
}