链表面试题（二）

最新推荐文章于 2024-06-20 00:50:50 发布
最新推荐文章于 2024-06-20 00:50:50 发布
阅读量259 收藏
点赞数 1
分类专栏： 数据结构 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iconm/article/details/80543196
版权

本文所有的函数都是在上上一篇单链表和上一篇链表面试题（一）的基础上建立的。单链表、链表面试题（一）

1、单链表排序(冒泡排序)

用三个指针来实现该功能，p1初始化为pHead，p2初始化为pHead->pNext,pEnd初始化为NULL，当p2不等于pEnd时，p1和p2的data进行比较，如果p1的data大于p2的data，p1和p2的值交换，否则p1和p2继续向后访问，pEnd指向pHead->pNext时，循环结束。
优化：创建一个标志位IsChange，如果交换将其置为1，当IsChange在一次循环中没有改变时，说明链表此时已经为有序链表，直接跳出循环。
这里写图片描述

函数实现源程序
Swap(int *x,int *y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

//单链表排序(冒泡排序)
void BubbleSort(SList *pHead)
{
    SList *p1 = pHead;
    SList *p2 = pHead->pNext;
    SList *pEnd = NULL;
    int IsChange = 0;
    while(pEnd != pHead->pNext)
    { 
        IsChange = 0;
        p1 = pHead;
        p2 = pHead->pNext;

        while(p2 != pEnd)
        {
            if(p1->data > p2->data)
            {
                Swap(&(p1->data),&(p2->data));
                IsChange = 1;
            }
            p1 = p1->pNext;
            p2 = p2->pNext;
        }
        if(IsChange == 0)
            break;
        pEnd = p1;
    }
}
测试程序
void TestBubbleSort()
{
    SList *Head = NULL;
    Init(&Head);

    PushFront(&Head,1);
    PushFront(&Head,2);
    PushFront(&Head,3);
    PushFront(&Head,4);
    PushBack(&Head,11);
    PushBack(&Head,12);
    PushBack(&Head,13);
    PushBack(&Head,14);
    Print(Head);

    //单链表排序(冒泡排序)
    BubbleSort(Head);
    Print(Head);

    Destory(&Head);
}
执行结果：

这里写图片描述

2、合并两个有序链表，合并后依然有序

用两个指针分别指向两个链表，哪个小，就将哪个尾插到新的链表中，并向后走接着比较，当其中有一个链表结束，那么剩下的那个链表只需依次尾插到新链表即可。
这里写图片描述

函数实现源程序
//合并两个有序链表，合并后依然有序
SList *MergeSort(SList *pHead1,SList *pHead2)
{
    SList *pNode1 = pHead1;
    SList *pNode2 = pHead2;
    SList *pNode = NULL;
    SList *pResult = NULL;
    SList *pRemain = NULL;

    while(pNode1 != NULL && pNode2 != NULL)
    {
        if(pNode1->data > pNode2->data)
        {
            PushBack(&pResult,pNode2->data);
            pNode2 = pNode2->pNext;
        }
        else
        {
            PushBack(&pResult,pNode1->data);
            pNode1 = pNode1->pNext;
        }
    }
    if(pNode1 == NULL)
        pRemain = pNode2;
    else
        pRemain = pNode1;
    for(pNode=pRemain; pNode!=NULL; pNode=pNode->pNext)
    {
        PushBack(&pResult,pNode->data);
    }
    return pResult;
}
测试程序
void TestMergeSort()
{
    SList *Head1 = NULL;
    SList *Head2 = NULL;

    Init(&Head1);
    Init(&Head2);

    PushBack(&Head1,1);
    PushBack(&Head1,3);
    PushBack(&Head1,4);
    PushBack(&Head1,6);
    PushBack(&Head1,9);
    Print(Head1);

    PushBack(&Head2,0);
    PushBack(&Head2,1);
    PushBack(&Head2,2);
    PushBack(&Head2,4);
    PushBack(&Head2,5);
    PushBack(&Head2,9);
    PushBack(&Head2,11);

    Print(Head2);

    Print(MergeSort(Head1,Head2));//合并两个有序链表，合并后依然有序

    Destory(&Head2);
    Destory(&Head1);
}
执行结果：

这里写图片描述

3、求两个已排序单链表中相同的数据

思路和第二题相同，用两个指针来遍历两个链表，当两个链表的数据相同时，将其尾插到新链表。

函数实现源程序
//求两个已排序单链表中相同的数据
SList *UnionSet(SList *pHead1,SList *pHead2)
{
    SList *pNode1 = pHead1;
    SList *pNode2 = pHead2;
    SList *pNode = NULL;
    SList *pResult = NULL;

    while(pNode1 != NULL && pNode2 != NULL)
    {
        if(pNode1->data > pNode2->data)//如果pNode1->data大于pNode2->data,pNode2向后走
        {
            pNode2 = pNode2->pNext;
        }
        else if(pNode1->data < pNode2->data)//如果pNode1->data小于pNode2->data,pNode1向后走
        {
            pNode1 = pNode1->pNext;
        }
        else//如果pNode1->data等于pNode2->data,将该数尾插到pResult，pNode1和pNode2同时向后走
        {
            PushBack(&pResult,pNode1->data);
            pNode1 = pNode1->pNext;
            pNode2 = pNode2->pNext;
        }
    }
    return pResult;
}
测试程序
void TestUnionSet()
{   
    SList *Head1 = NULL;
    SList *Head2 = NULL;

    Init(&Head1);
    Init(&Head2);

    PushBack(&Head1,1);
    PushBack(&Head1,3);
    PushBack(&Head1,4);
    PushBack(&Head1,6);
    PushBack(&Head1,9);
    Print(Head1);

    PushBack(&Head2,0);
    PushBack(&Head2,1);
    PushBack(&Head2,2);
    PushBack(&Head2,4);
    PushBack(&Head2,5);
    PushBack(&Head2,9);
    PushBack(&Head2,11);

    Print(Head2);

    Print(UnionSet(Head1,Head2));//求两个已排序单链表中相同的数据

    Destory(&Head2);
    Destory(&Head1);
}
执行结果：

这里写图片描述

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

使用两个指针pSlow和pFast，pFast每次走两步，pSlow每次走一步，当pFast走完的时候，pSlow刚好走到链表的中间节点。

函数实现源程序
//查找链表的中间节点，要求只能遍历一次链表
SList *FindMiddle(SList *pHead)
{
    SList *pSlow = pHead;
    SList *pFast = pHead;
    assert(pHead != NULL);

    while(pFast != NULL)
    {
        pFast = pFast->pNext;
        if(pFast != NULL)
        {
            pFast = pFast->pNext;
        }
        else
        {
            break;
        }
        pSlow = pSlow->pNext;
    }
    return pSlow;
}
测试程序
void TestFindMiddle()
{
    SList *Head1 = NULL;

    Init(&Head1);

    PushBack(&Head1,1);
    PushBack(&Head1,3);
    PushBack(&Head1,4);
    PushBack(&Head1,6);
    PushBack(&Head1,9);
    Print(Head1);

    printf("%d\n",FindMiddle(Head1)->data);//查找中间节点

    Destory(&Head1);
}
执行结果：

这里写图片描述

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

和第4题相同，仍然采用快慢指针的方法，要找倒数第K个节点，就让快指针先走K步，当快指针走完链表时，慢指针指向链表的倒数第K个节点。

函数实现源程序
//查找单链表的倒数第K个节点，要求只能遍历一次链表
SList *FindKNode(SList *pHead,int k)
{
    SList *pSlow = pHead;
    SList *pFast = pHead;
    int i = 0;
    for(i=0; i<k; i++)//快指针先走k步
    {
        pFast = pFast->pNext;
    }
    while(pFast != NULL)
    {
        pSlow = pSlow->pNext;
        pFast = pFast->pNext;
    }
    return pSlow;
}
测试程序
void TestFindKNode()
{   
    SList *Head1 = NULL;

    Init(&Head1);

    PushBack(&Head1,1);
    PushBack(&Head1,3);
    PushBack(&Head1,4);
    PushBack(&Head1,6);
    PushBack(&Head1,9);
    Print(Head1);

    printf("%d\n",FindKNode(Head1,2)->data);//查找倒数第k个节点

    Destory(&Head1);
}
执行结果：（找倒数第二个）

这里写图片描述

6、删除链表的倒数第K个

函数实现源程序
//删除链表的倒数第K个
void DeleteKNode(SList **ppHead,int k)
{
    SList *pPos = FindKNode(*ppHead,k);
    SList *pNode = *ppHead;
    if(pPos->pNext == NULL)//如果是尾节点就尾删
    {
        PopBack(ppHead);
    }
    else//否则删除一个非尾结点
    {
        DelNoTailNode(pPos);
    }
}
测试程序
void TestDeleteKNode()
{
    SList *Head1 = NULL;

    Init(&Head1);

    PushBack(&Head1,1);
    PushBack(&Head1,3);
    PushBack(&Head1,4);
    PushBack(&Head1,6);
    PushBack(&Head1,9);
    Print(Head1);

    DeleteKNode(&Head1,2);//删除倒数第k个节点
    Print(Head1);

    Destory(&Head1);
}
执行结果：（删除倒数第二个节点）

这里写图片描述

不负韶华-z
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表面试题
你又来看我了，一起学习吧
09-11 4327
前言： 在面试中，最经常被提及的就是链表，，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，当插入一个结点时，只需要为该结点分配内存，然后调整指针的指向来确保新结点被连接到链表中。所以，它不像数组，内存是一次性分配完毕的，而是每添加一个结点分配一次内存。正是因为这点，所以...
链表笔试面试题
热门推荐
fatshaw的专栏
05-28 1万+
<br />1.已知链表的头结点head,写一个函数把这个链表逆序<br />void List::reverse() { list_node * p = head; list_node * q = p->next; list_no
链表经典面试题--链表修至圆满
最新发布
pzn2506的博客
06-20 781
追上了 错过了---->进行新得一轮追击，距离变成C-1（假设C是环得长度）两种情况：1.C-1是偶数 2.C-1是奇数。由此，N是1奇数时，C也是奇数；N是偶数是，C也是偶数。结论：如果同时存在N是奇数且C是偶数，那么就永远追不上。假设slow进环时，fast跟slow距离时N，假设slow进环时，fast跟slow距离时N，N是奇数第一轮追不上，C-1是偶数第二轮就追上了。2.N是奇数，第一轮追击会错过，距离变成C-1。所以，N是奇数且C是偶数不能同时存在，
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
链表面试题总结
10-22
### 面试题二：寻找链表相交的第一个节点 对于两个链表，可能存在相交的情况，即它们共享一部分节点。为了找到相交的第一个节点，可以先计算出两个链表的长度差，然后让较长的链表先移动这个差值，之后两个链表同时...
有关链表的面试题
08-28
链表反转是常见的面试题，可以通过迭代或递归实现。迭代法通常涉及三个指针：前驱、当前和后续，每次将当前节点的指针指向前驱，然后更新前驱和当前指针。递归法则通过递归调用函数，将当前节点的后续节点设为其...
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
反转链表（leetcode每日打卡）
m0_60264772的博客
11-15 363
目录 题目描述 思路 题解 题目描述 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 思路 假设链表为 1→2→3→∅，我们想要把它改成∅←1←2←3。 在遍历链表时，将当前节点的 \textit{next}next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。 题解 c.
C++链表反转面试题与答案详解
首先，针对链表反转问题，它是一个经典的面试题目，涉及基础的数据结构操作。在单向链表中，要实现反转，可以采用迭代或递归的方法。迭代方法通过设置两个指针，一个pre指向前一个节点，一个cur指向当前节点，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值