单链表的各种操作（面试必备）

最新推荐文章于 2023-11-22 22:43:37 发布

LaoJiu_

最新推荐文章于 2023-11-22 22:43:37 发布

阅读量988

点赞数 1

分类专栏： ACM 与数据结构文章标签：单链表面试数据结构链表合并

本文链接：https://blog.csdn.net/LaoJiu_/article/details/56668541

版权

ACM 与数据结构专栏收录该内容

36 篇文章 4 订阅

订阅专栏

一：前言

单链表经常为公司面试所提及，先不贬其过于简单，因为单链表确实是数据结构中最简单的一部分，但往往最简单的，人们越无法把握其细节。本文一共总结了单链表常被提及的各种操作，如下：
（1）逆序构造单链表；
（2）链表反转；
（3）链表排序；
（4）合并两个有序链表；
（5）求出链表倒数第k个值；
（6）判断链表是否有环，有环返回相遇节点；
（7）在一个有环链表中找到环的入口；
（8）删除当前节点；
（9）找出链表的中间节点。

本文中的所有操作均针对带有头结点的单链表。请注意：头结点和第一结点是两个结点，百度百科解释为：为方便操作，在单链表的第一个结点之前附设一个结点，称之为头结点。本文中用header代替头结点。

在继续下文之前先约定下节点结构：

/* 定义节点 */
struct Node
{
    int data;
    Node * next;
    Node() { data = 0; next = nullptr; }
};

/* 定义头结点 */
Node * header = new Node;

二：具体分析与实现代码

2.1 逆序构造单链表

例如：输入数据：1 2 3 4 5 6，构造单链表：6->5->4->3->2->1。

/* 逆序构造单链表，-1结束输入 */
void desc_construct(Node * header)
{
    Node * pre = nullptr;  //前一个节点
    int x;
    while (cin >> x && x != -1)
    {
        Node * cur = new Node;
        cur->data = x;
        cur->next = pre;  //指向前一个节点
        pre = cur;        //保存当前节点
    }
    header->next = pre;  //头结点指向第一节点
}

2.2 链表反转

例如：假设现有链表：6->5->4->3->2->1，进行反转操作后，链表变成：1->2->3->4->5->6。

/* 反转链表 */
void reverse(Node * header)
{
    if (!header->next || !header->next->next)  //如果是空链表或链表只有一个节点
        return;
    Node * cur = header->next;  //指向第一个节点
    Node * pre = nullptr;
    while (cur)
    {
        Node * temp = cur->next;  //保存下一个节点
        cur->next = pre;          //调整指向
        pre = cur;                //pre前进一步
        cur = temp;               //cur前进一步
    }
    header->next = pre;  //头结点指向反转后的第一节点
}

2.3 链表升序排序

我们希望用最小的时间复杂度来完成这个排序任务。归并排序是个不错的选择，平均时间复杂度 $T(n)=O(nlogn)$ ，但是还有其他方法么？

我们想到经常出现的快排，快排是需要一个指针指向头，一个指针指向尾，然后两个指针相向运动并按一定规律交换值，最后使得支点左边小于支点，支点右边大于支点，但是对于单链表而言，指向结尾的指针很好办，但是这个指针如何往前，我们只有一个next（这并不是一个双向链表）。

如果是这样的话，对于单链表我们没有前驱指针，怎么能使得后面的那个指针往前移动呢？所以这种快排思路行不通，如果我们能使两个指针都往next方向移动并且也可以按相同规律交换值那就好了，怎么做呢？

接下来我们使用快排的另一种思路来解答。我们只需要两个指针i和j，这两个指针均往next方向移动，移动的过程中保持i之前的data都小于base，i和j之间的data都大于base，那么当j走到末尾的时候便完成了一次支点的寻找。若以swap操作即if判断语句成立作为基本操作，其操作数和快速排序相同，故该方法的平均时间复杂度亦为 $T(n)=O(nlogn)$ 。

/**
 * 链表升序排序
 * 
 * begin 链表的第一个节点，即header->next
 * end   链表的最后一个节点的next，即nullptr
 */
void asc_sort(Node * begin, Node * end)
{
    if (begin == end || begin->next == end)  //链表为空或只有一个节点
        return;
    int base = begin->data;   //设置基准
    Node * i = begin;         //i左边的小于base
    Node * j = begin->next;   //i和j中间的大于base
    while (j != end)
    {
        if (j->data < base)
        {
            i = i->next;
            swap(i->data, j->data);
        }
        j = j->next;
    }
    swap(i->data, begin->data);

    asc_sort(begin, i);      //递归左边
    asc_sort(i->next, end);  //递归右边
}

2.4 合并两个有序的单链表

为简化问题，以下代码为合并两个升序链表。

/* 合并两个有序链表 */
void asc_merge(Node * header, Node * other_header)
{
    asc_sort(header->next, nullptr);  //保证有序
    asc_sort(other_header->next, nullptr);

    if (!header->next)  //链表为空
    {
        header->next = other_header->next;  //合并后两个header指向第一个节点
        return;
    }
    if (!list->header->next)  //链表为空
    {
        other_header->next = header->next;  //合并后两个header指向第一个节点
        return;
    }

    Node * p = nullptr;                         //还需一个指针，指向合并的节点
    Node * this_pointer = header->next;         //第一个节点
    Node * other_pointer = other_header->next;  //第一个节点

    //单独考虑合并的第一个节点
    if (this_pointer->data < other_pointer->data)
    {
        other_header->next = p = this_pointer;  //p指向新合并的节点
        this_pointer = this_pointer->next;      //前进一步
    }
    else
    {
        header->next = p = other_pointer;      //p指向新合并的节点
        other_pointer = other_pointer->next;   //前进一步
    }

    while (this_pointer && other_pointer)
    {
        if (this_pointer->data < other_pointer->data)
        {
            p->next = this_pointer;  //合并新节点
            p = this_pointer;        //p前进一步指向新合并的节点
            this_pointer = this_pointer->next;
        }
        else
        {
            p->next = other_pointer;  //合并新节点
            p = other_pointer;        //p前进一步指向新合并的节点
            other_pointer = other_pointer->next;
        }
    }

    //处理剩下的节点
    if (this_pointer)
        p->next = this_pointer;
    if (other_pointer)
        p->next = other_pointer;
}

2.5 返回链表倒数第k个值

例如，给定链表1->4->3->5->6->8，返回倒数第3个数，也就是5。要求，只给定链表，但并不知道链表长度，如何在最短时间内找出这个倒数第k个值。

其实思路很简单，假设K是小于等于链表长度，那么我们可以设置两个指针p和q，这两个指针的距离在链表里的距离就是K，那么当一个指针走到链表末尾的nullptr时，另一个指针肯定指向链表倒数第k个值。

/* 返回链表倒数第k个值 */
int kth_last(Node * header, int k)
{
    Node * p = header->next;
    Node * q = p;

    for (int i = 0; i < k; i++)
    {
        if (!q)
        {
            cout << "链表长度小于k\n";
            return -1;
        }
        q = q->next;
    }

    while (q)
    {
        q = q->next;
        p = p->next;
    }
    return p->data;
}

2.6 判断链表是否有环，有环返回相遇节点

有环是什么意思？一个单链表最后一个节点的位置的next应该是nullptr，标志着链表的结尾，但是如果现在这个next指向了链表里的某一个节点（可以是自身），那么这个链表就存在环。如下图：

因此我们只要找到两个节点，其地址相同（因为两个节点的data可能相同），即可断定有环。

我们的思路就是：设置两个快慢指针（快慢指针即两个指针起点相同，慢指针每次走一步，快指针走两步），让它们一直往下走，直到它们相等，说明有环；遇到nullptr，说明无环。下面简单证明：如上图，A为链表第一个节点，B为环与链表的交叉点，C为slow_pointer与fast_pointer相遇的位置。假设环的长度为r，则有

A B + B C + t 1 r = A B + B C + t 2 r 2 (左 为 慢 指 针 ， 右 为 快 指 针)

$AB+BC+t_1r=\frac {AB+BC+t_2r}{2} \tag{左为慢指针，右为快指针}$

化简为：

A B + B C = (t 2 - 2 t 1) r (t1,t2 为 整 数)

$AB+BC=(t_2-2t_1)r \tag{t1,t2为整数}$

在确定了AB和r后，只需调整BC，使AB+BC能整除r即可。

/* 判断链表是否有环，有环返回相遇节点 */
Node * is_loop(Node * header)
{
    if (!header->next)//空链表
        return nullptr;
    Node * slow_pointer = header;
    Node * fast_pointer = header;
    while (fast_pointer->next && fast_pointer->next->next && slow_pointer != fast_pointer)
    {
        slow_pointer = slow_pointer->next;        //慢指针走一步
        fast_pointer = fast_pointer->next->next;  //快指针走两步
    }

    if (slow_pointer == fast_pointer)
        return slow_pointer;

    return nullptr;
}

2.7 在一个有环链表中找到环的入口

参考2.6图，若存在环且找到了相遇点C，此时令一个指针start_node从链表第一个节点处开始往后遍历，再令另一个指针meet_node从C处往后遍历，它们的相遇节点就是环的入口点。为什么呢？

2.6公式已经证明了：若快慢指针相遇在C点，则：

A B + B C = t r (t 是 整 数)

$AB+BC=tr \tag{t是整数}$
进一步整理上式为：

A B = (r - B C) + (t - 1) r (其 中 r-BC 的 含 义 请 对 照 2.6 图)

$AB=(r-BC)+(t-1)r \tag{其中r-BC的含义请对照2.6图}$
好了，至此，证明就已经很显然了。当start_node走了r-BC距离后，meet_node正好到达入口处B点，此时start_node还剩(t-1)r距离，显然两个指针继续走的话，一定会相遇在入口处B点。

/* 在一个有环链表中找到环的入口 */
Node * find_meet_node(Node * header)
{
    Node * meet_node = is_loop(header);
    if (meet_node == nullptr)  //不存在环
        return nullptr;
    Node * start_node = header->next;
    while (start_node != meet_node)
    {
        start_node = start_node->next;
        meet_node = meet_node->next;
    }
    return start_node;
}

此外，我们也会遇到“判断两个链表是否相交”，“求出两个相交链表的交点”这样的问题，百变不离其宗，我们只需把链表尾接到其中一个链表头就转化为2.6和2.7的问题，所以在这里不作详述了。

2.8 删除当前节点

题意规定，给定要删除的节点和头结点，现要你删除这个节点，要求平均时间复杂度为 $T(n)=O(1)$ 。

例如，现有这样的链表，1->2->3->4->5->6，需要删除4，我们的思路肯定是先找到4的前一个节点3，和4的后一个节点5，然后把3和5连起来，再把4删除。但是这样做的话，我们需要花费 $O(n)$ 的时间来找到3和5，与题意要求的 $O(1)$ 相距甚远。

我们之所以需要从头结点开始查找要删除的结点，是因为我们需要得到要删除结点的前一个结点。我们试着换一种思路。如果我们要删除4，可以把4和5的数据交换下，然后删除5，再把4和6连接起来，如此其时间复杂度为 $O(1)$ 。

上面的思路还有一个问题：如果删除的结点位于链表的尾部，没有下一个结点，怎么办？我们仍然从链表的头结点开始，顺便遍历得到给定结点的前序结点，并完成删除操作。这个时候时间复杂度是 $O(n)$ 。那题目要求我们需要在 $O(1)$ 时间完成删除操作，我们的算法是不是不符合要求？实际上，假设链表总共有n个结点，我们的算法在n-1个情况下，时间复杂度是 $O(1)$ ，只有当给定的结点处于链表末尾的时候，时间复杂度为 $O(n)$ 。因此其平均时间复杂度 $\frac {(n-1)⋅O(1)+1⋅O(n)}n$ ，仍然为 $O(1)$ 。

/* 删除当前节点 */
void del(Node * header, Node * position)
{
    if (!position->next)  //要删除的是最后一个节点
    {
        Node * p = header;
        while (p->next != position)
            p = p->next;  //找到position的前一个节点
        p->next = nullptr;
        delete position;
    }
    else
    {
        Node * p = position->next;
        swap(p->data, position->data);
        position->next = p->next;
        delete p;
    }
}

2.9 找出单链表的中间节点

题意要求，给定链表头结点，在最小复杂度下输出该链表的中间节点。
如果只知链表的头结点，我们一般的思路就是先遍历链表得到链表长度，然后再遍历一遍得到中间节点，如此时间复杂度为 $O(n)+O(\frac n2)$ 。

上面的思路似乎不太令人满意。我们又想到快慢指针，它有一个很重要的性质：慢指针走的长度等于快慢指针相距的程度。所以利用这个性质，当快指针走到链表尾时，慢指针正好在中间节点。

/* 找出单链表的中间节点 */
Node * find_middle(Node * header)
{
    Node * slow_pointer = header;
    Node * fast_pointer = header;

    while (fast_pointer->next && fast_pointer->next->next)
    {
        slow_pointer = slow_pointer->next;        //慢指针走一步
        fast_pointer = fast_pointer->next->next;  //快指针走两步
    }

    return slow_pointer;
}

转载自我的个人博客：http://www.61mon.com/index.php/archives/179/

LaoJiu_

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
单链表的各种操作（面试必备）

一：前言本篇不会涉及基础知识，我默认来到这里的读者已经掌握何谓链表，何谓链表的头结点等基础概念。单链表经常为公司面试所提及，先不贬其过于简单，因为单链表确实是数据结构中最简单的一部分，但往往最简单的，人们越无法把握其细节。本文一共总结了单链表常被提及的八种操作，如下：（1）逆序构造单链表；（2）链表反转；（3）链表排序；（4）合并两个有序链表；
复制链接

扫一扫

专栏目录