C语言单链表——之常见面试题目2

最新推荐文章于 2024-09-01 10:42:03 发布
最新推荐文章于 2024-09-01 10:42:03 发布
阅读量515 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cherry_ermao/article/details/50954296
版权

接上篇还是无头节点的：

实现的函数声明：

// 从头至尾打印单链表
void PrintListTailToHead(PSlist pHead);

// 链表的非头结点前插入元素data
void InsertNotHead(PSlist pHead, PSlist pos, Datatype data);

// 删除链表的非尾结点
void DelNotTailNode(PSlist pos);

// 查找链表的中间结点，要求只遍历一次链表
PSlist FindMidNode(PSlist pHead); //返回1return 2参数 3结构体打包返回
PSlist FindMidNode2(PSlist pHead);//偶数返回后一个


// 约瑟夫环问题
PSlist JosephCircle(PSlist pHead, int M);

// 单链表逆置：两种方法都实现：一、三个指针  二、尾插发
PSlist ReverseList(PSlist* pHead);

// 单链表排序：冒泡(优化版本)
void SortList(PSlist pHead);

// 查找链表的倒数第K个结点
PSlist FindLastKNode(PSlist pHead, int K，int size);

// 判断链表是否带环
PSlist HasCycle(PSlist pHead);

// 求环的长度
int GetCyleLen(PSlist pMeetNode);

// 合并两个已序单链表
PSlist MergeList(PSlist pL1, PSlist pL2);

//查找环的入口
PSlist FindEnterNode(PSlist pHead, PSlist pMeetMode);
//判断两个链表是否相交 判断尾节点
//y 前面不相同的个数相同
//v 
// y 前面节点个数不相同
//方法2：让他构成环求交点

// 两个链表是否相交(不带环)
int IsMeet(PSlist pos1, PSlist pos2);
//1都不带环 == Ismeet
//2有且只有一个带环  不相交 相当于3
//3两个都带环 M1 M2 相遇会出现M1 = M2 

// 两个链表是否相交，带环
int IsMeetwithcycle(PSlist pos1, PSlist pos2);

实现：

void PrintListTailToHead(PSlist pHead)
{
    if (pHead == NULL)
    {
        return;
    }
    else
    {
        PrintListTailToHead(pHead->next);
        printf("%d->", pHead->data);
    }
}

void InsertNotHead(PSlist pHead,PSlist pos, Datatype data)
{
    assert(pHead);
    assert(pos);
    PSlist pNew = BuyNode(pos->data);

    if (pos == pHead || pos == pHead->next)
    {
        return;
    }

    pos->data = data;
    pNew->next = pos->next;
    pos->next = pNew;

}

void DelNotTailNode(PSlist pos)
{
    PSlist pCur = pos->next;
    if (pos == NULL)
    {
        return;
    }
    if (pos->next == NULL)
    {
        return;
    }
    pos->data = pCur->data;
    pos->next = pCur->next;
    free(pCur);
    pCur->next = NULL;
}

PSlist FindMidNode(PSlist pHead)//偶数返回前一个
{
    if (pHead == NULL || pHead->next == NULL)
    {
        return NULL;
    }

    PSlist pSlow = pHead;
    PSlist pFast = pSlow->next;

    while (pFast && pFast->next)
    {
        pSlow = pSlow->next;

        pFast = pFast->next;
        pFast = pFast->next;
    }
    return pSlow;
}

PSlist FindMidNode2(PSlist pHead)//偶数返回后一个
{
    if (pHead == NULL || pHead->next == NULL)
    {
        return NULL;
    }
    PSlist pSlow = pHead;
    PSlist pFast = pSlow->next;
    while(pFast &&pFast->next)
    { 
        pSlow = pSlow->next;

        pFast = pFast->next;
        pFast = pFast->next;
    }
    pSlow = pSlow->next;
    return pSlow;
}


PSlist JosephCircle(PSlist pHead, int M)
{
    if (pHead == NULL || pHead->next == NULL || M <= 0)
    {
        return NULL;
    }
    PSlist pNode = NULL;
    int k = 0;
    while (pHead->next != pHead)//最后一个不进去
    {
        k = M;
        pNode = pHead->next;
        while (--k)
        {
            pHead = pHead->next;
            pNode = pNode->next;
        }
        pHead->data = pNode->data;
        pHead->next = pNode->next;
        free(pNode);
        pNode->next  = NULL;
    }

    return pHead;
}

void DestroyList(PSlist* pHead)
{
    assert(pHead);
    PSlist pCur = *pHead;
    PSlist pDel = NULL;
    if (pCur == NULL)
    {
        return;
    }
    while (pCur)
    {
        pDel = pCur;
        pCur = pCur->next;
        free(pDel);
        pDel->next = NULL;
    }

}

PSlist ReverseList(PSlist* pHead)
{
    assert(pHead);
    PSlist pCur = *pHead;
    PSlist pNewHead = pCur->next;
    pCur->next = NULL;
    PSlist pNode = NULL;


    while (pNewHead)
    {
        pNode = pNewHead;
        pNewHead = pNewHead->next;
        pNode->next = pCur;
        pCur = pNode;
    }
    pNewHead = NULL;
    return pCur;
}


void SortList(PSlist pHead)
{
    if (pHead == NULL && pHead->next == NULL)
    {
        return;
    }
    PSlist pCur =NULL;
    PSlist pTail =NULL;
    while (pHead != pTail)
    {
        pCur = pHead;
        pTail = pHead->next;
        while (pCur->next)//哎！跳不出去嘞
        {
            if (pCur->data > pTail->data)
                pCur->data ^= pTail->data ^= pCur->data ^= pTail->data;
            pCur = pTail;
            pTail = pTail->next;        

        }
        pTail = NULL;
    }
}

判断单链表有无环
///
int  HasCycle(PSlist pHead)
{
    PSlist pFast = pHead;
    PSlist pSlow = pHead;
    if (pHead == NULL)
    {
        return -1;
    }
    while (pFast && pFast->next)
    {
        pSlow = pSlow->next;
        pFast = pFast->next->next;
        if (pSlow == pFast)
        {
            return 1;
        }
    }
}


PSlist FindLastKNode(PSlist pHead, int K,int size)
{
    int i = 0;
    int M = K;
    if (K <= 0 && K > size)
    {
        return NULL;
    }
    PSlist pFast = pHead;
    PSlist pSlow = NULL;

    while (M-- && pFast->next != NULL)
    {
        pFast = pFast->next;
    }
    pSlow = pHead;
    while (pFast->next != NULL)
    {
        pFast = pFast->next;
        pSlow = pSlow->next;
    }

    return pSlow;
}

PSlist MergeList(PSlist pL1, PSlist pL2)
{
    if (pL1 == NULL || pL2 == NULL)
        return pL1 == NULL ? pL2 : pL1;

    PSlist cur = pL1;
    if (pL1->data > pL2->data)
    {
        cur = pL2;
        pL2 = pL2->next;
    }
    else
    {
        pL1 = pL1->next;
    }

    PSlist NewHead = cur;
    while (pL1 != NULL && pL2 != NULL)
    {
        if (pL1->data < pL2->data)
        {
            cur->next = pL1;
            pL1 = pL1->next;
        }
        else
        {
            cur->next = pL2;
            pL2 = pL2->next;
        }
        cur = cur->next;
    }
    if (pL1 != NULL)
        cur->next = pL1;
    else
        cur->next = pL2;

    return NewHead;
}
//
PSlist FindLastKNode(PSlist pHead, int K)
{
    if (K == 0 || pHead == NULL)
        return NULL;

    PSlist fast = BuyNode(-1);
    PSlist slow = fast;

    for (size_t i = 0; i < K - 1; ++i)
    {
        if (fast->next)
            fast = fast->next;
        else
        {
            return 0；
        }
    }

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

int IsMeet(PSlist pos1, PSlist pos2)
{
    PSlist pNode1 = pos1;
    PSlist pNode2 = pos2;
    if (pos1 == NULL || pos2 == NULL)
    {
        return 0;
    }

    //y字型
    while (pNode1->next != NULL)
    {
        pNode1 = pNode1->next;
    }
    while (pNode2->next != NULL)
    {
        pNode2 = pNode1->next;
    }

    if (pNode1 == pNode2)
    {
        return 1;//相交
    }
    return 0;
}

int IsMeetwithcycle(PSlist pos1, PSlist pos2)
{
    PSlist pMeetpos1 = NULL;
    PSlist pMeetpos2 = NULL;

    PSlist pNode1 = pos1;
    PSlist pNode2 = pos2;

    if (pos1 == NULL || pos2 == NULL)
    {
        return 0;
    }

    pMeetpos1 = HasCycle(pos1);
    pMeetpos2 = HasCycle(pos2);
//都没有环
    if (pMeetpos1 == NULL || pMeetpos2 == NULL)
    {
        while (pNode1->next != NULL)
        {
            pNode1 = pNode1->next;
        }
        while (pNode2->next != pNode2)
        {
            pNode2 = pNode2->next;
        }
        if (pNode1 == pNode2)//L = nc-x 环足够大n可能等于1，环小n可能>1
        {
            return 1;
        }
        return 0;
    }
//两个都带环 M2是 M1的前一个（相遇点相同）
    if (pMeetpos1 != NULL && pMeetpos2 != NULL)
    {
        PSlist pNode = pMeetpos1;
        while(pNode->next!=pMeetpos1)
        {
            if (pMeetpos1 == pMeetpos2)
            {
                return 1;
            }

            pNode = pNode->next;
        }
        return 0;
    }
    return 0;
}
//PrintTailtoHead
void Fun4()
{
    PSlist slist;
    InitList(&slist);
    PushFront(&slist, 1);
    PushFront(&slist, 2);
    PushFront(&slist, 3);
    PushFront(&slist, 4);

    PrintListTailToHead(slist);
}
//InsertNotHead
void Fun5()
{
    PSlist slist;
    InitList(&slist);
    PushFront(&slist, 1);
    PushFront(&slist, 2);
    PushFront(&slist, 3);
    PushFront(&slist, 4);
    InsertNotHead(slist, Find(slist, 4), 7);
    PrintList(slist);
}
//DelNotTailNode
void Fun6()
{
    PSlist slist;
    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);

    DelNotTailNode(Find(slist,4));
    PrintList(slist);

}

void Fun7()
{
    PSlist slist;
    PSlist item = NULL;
    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);
    PushBack(&slist, 5);
    PushBack(&slist, 6);
    PushBack(&slist, 7);
    PushBack(&slist, 8);
    item = FindMidNode2(slist);

}
//约瑟夫环
void Fun8()
{
    PSlist slist;
    PSlist Tail= NULL;
    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);
    //构造环
    Tail = Find(slist, 4);
    Tail->next = slist;
    Tail = JosephCircle(slist, 3);

    //解开环
    Tail->next = NULL;
    DestroyList(&Tail);
}


void Fun9()
{
    PSlist slist;
    PSlist Tail = NULL;
    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);
    PrintList(slist);

    Tail = ReverseList(&slist);
    PrintList(Tail);
}

void Fun10()
{
    PSlist slist;
    PSlist Tail = NULL;
    InitList(&slist);
    PushBack(&slist, 4);
    PushBack(&slist, 3);
    PushBack(&slist, 2);
    PushBack(&slist, 1);
    PrintList(slist);                                   

    SortList(slist);
}

void Fun11()
{
    PSlist slist;
    PSlist pos1 = NULL;
    PSlist pos2 = NULL;

    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);
    PushBack(&slist, 5);
    PushBack(&slist, 6);
    PushBack(&slist, 7);
    PushBack(&slist, 8);
    PushBack(&slist, 9);

    //构造环
    pos1 = Find(slist, 9);
    pos2 = Find(slist, 5);
    pos1->next = pos2;
    pos1 = FindEnterNode(slist, HasCycle(slist));

}

void Fun12()
{
    PSlist slist;
    PSlist pos1 = NULL;
    PSlist pos2 = NULL;

    InitList(&slist);
    PushBack(&slist, 1);
    PushBack(&slist, 2);
    PushBack(&slist, 3);
    PushBack(&slist, 4);
    PushBack(&slist, 5);
    PushBack(&slist, 6);
    PushBack(&slist, 7);
    PushBack(&slist, 8);
    PushBack(&slist, 9);

    pos1 = Find(slist, 1);

}
int main()
{
//  int a[5] = { 5,4,3,2,1 };
//  sort(a, 5);
    //Fun1();
    //Fun2();
    //Fun3();
    //Fun4();
    //Fun5();
    //Fun6();
    //Fun7();
    //Fun8();
    //Fun9();
    Fun10();
    return 0;
}
一只名叫二毛的猫
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【数据结构】链表OJ特别篇 —— 面试情景带你深度剖析 环形链表系列问题 && 复制带随机指针的链表
StackFrame
11-09 1341
模拟面试情景详解：环形链表系列问题、复制带随机指针的链表
算法岗常见面试题
热门推荐
炼金术的修行
09-06 1万+
深度学习/机器学习 1.讲一讲faster_rcnn RCNN 首先从rcnn讲起，rcnn可以称得上是用深度学习进行目标检测的开山之作。其方法是首先用Selective Search算法选出约2000-3000个候选区域(region proposal)，然后将这些区域图块归一化成227*227的图像，再通过CNN提取特征，得到4096维的特征。接下来分为两步：对上面每一个区域得到的特征都用一...
C语言递归单链表反转,C语言之单链表反转（递归，迭代），排序
weixin_36140403的博客
05-21 991
C语言之单链表反转(递归，迭代)，排序前言这篇会是关于单链表最后一篇的介绍，之前还介绍过的文章分别是：单链表及各项操作介绍单链表初始化单链表打印(遍历)，查询，定位，插入，删除，链表长度单链表反转，排序，即本文单链表反转之迭代对于单链表很多的基本算法，甚至是树结构，在这本人都比较建议各位不要用大脑想如何实现，而是在本子上画出来它的步骤，即使是个大概也好，必须先要有思路再敲代码。所以在这里先用图解来...
【初阶数据结构】——链表常见面试题剖析
m0_70980326的博客
01-09 1341
几道链表相关的经典面试题解析
C语言实现单链表面试题汇总
ljx_5489464的博客
03-20 2909
这篇博客只有针对单链表的不同面试题的不同函数，没有对单链表的具体实现方法的介绍。 单链表的具体实现方法（创建，初始化，前插，后插，删除，插入，销毁等），可以参考我的另一边博客： http://blog.csdn.net/ljx_5489464/article/details/50893430以下是单链表面试题的具体实现：1、从尾到头打印单链表void PrintListTailToHead(PS
单链表的实现和相关面试题及其详解（C语言）
半暖的博客
08-02 509
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的链接次序实现的 链表 链表 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
笔试or面试——寻找单链表倒数第n个元素
Floating Cat
11-23 2919
在各种面试笔试中，单链表考察的最多。其中有一道
Golang 常见面试题目解析
niwoxiangyu的博客
08-10 1138
交替打印数字和字母 问题描述 使用两个 goroutine 交替打印序列，一个 goroutine 打印数字， 另外一个 goroutine 打印字母， 最终效果如下：
[数据结构] 时间复杂度的理解
CL
11-27 5471
时间复杂度：函数计算之行的基本次数 面试tip：面试官问及时间复杂度不一定只有最坏的，一般人一般会直接答最坏的，其实还有最好和平均。 例如：在一个长度为N的线性表中搜索一个数据x。 最坏：没有找到，到最后才找到 平均：不好不坏到中间才找到 最好：很开心第一下就找到了，一般必须要关注，但是在哈希的时候会关注 官方的说法： 最坏情况：任意输入规模的最大运行时间。（上界）平均情况：
顺序表与单链表的比较
CL
03-22 1776
顺序表和单链表的优缺点对比： 顺序表的优点，无需为表示表中元素之间的逻辑关系而增加额外的存储空间； 可以快速的存取表中的任意位置的元素。 顺序表的缺点，插入后删除操作需要移动大量元素； 当线性表长度不稳定时，存储空间难确定，容易造成存储空间碎
[c语言]数据结构 顺序表的实现
CL
04-25 604
首先是main.cpp让我们来看看都有什么函数 #include #include"SeqList.h" using namespace std; int main() { SeqList mylist; InitSeqList(&mylist); int select = 1; ElemType item = 0; ElemType pos
C语言实现单链表——之基本操作1
CL
03-22 497
一般面试题中会考虑无头节点的单链表下面是一些实现： 声明Sqlist.h文件#pragma once #include <assert.h> #include <stdio.h> typedef int Datatype; typedef struct SList { Datatype data; struct SList* next; }SList, *PSlist; //无头结
【数据结构】顺序栈
CL
10-20 351
Stack.h#pragma once #include<stdlib.h> #include<iostream> using namespace std; #define SIZE 10 #define Elemtype int #define StackInit 10typedef struct Sqstack { Elemtype stack[SIZE]; int top; }
【数据结构】链栈
CL
10-20 310
Lstack.h#pragma once #include<iostream> #include <stdlib.h> using namespace std;#define Elemtype int typedef struct Nstack { Elemtype data; Nstack* next; }Node;//节点typedef struct { Node* t
C语言典型例题56
2302_77517102的博客
08-30 925
将范围为100~200的不能被3整除的数输出。
P0.9/P1.25全倒装共阴节能COB超微小间距LED显示屏已抢占C位
JRC15919765614的博客
08-31 611
倒装COB作为正装COB的升级产品，在正装COB超小点间距、高可靠性、面光源发光基础上进一步提升可靠性，简化生产工序、显示效果更佳、近屏体验完美、可实现真正意义上的芯片级间距，达到Micro的水平。封装层无焊线空间，封装层更轻薄，降低热阻，提升光品质，提高显示屏寿命。随着科技日新月异的进步，P0.9/P1.25全倒装共阴节能COB超微小间距LED显示屏凭借其卓越的显示性能与创新的节能设计，不仅在商业显示领域大放异彩，更在高端会议、舞台演艺、影院放映等多元化应用场景中稳坐C位，引领着显示技术的革新潮流。
C语言调用子函数时入/出栈（保护/恢复现场）全过程分析：以Cortex-M3为例
最新发布
kevin1499的博客
09-01 1416
使用C语言调用子函数是如何保护/恢复现场的呢？本文以Cortex-M3为例，逐行汇编代码分析C语言调用子函数时入/出栈（保护/恢复现场）全过程。
C语言单链表实现与接口详解
在C语言中实现单链表是基础的数据结构操作之一，本文将重点介绍不带头节点的单链表的实现方法。首先，理解单链表的定义至关重要，它是一种链式存储的线性表，由一系列节点组成，每个节点包含数据域（`DataType`）和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值