单链表的基本操作的相关题目

最新推荐文章于 2023-08-22 09:28:16 发布
最新推荐文章于 2023-08-22 09:28:16 发布
阅读量197 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenyifei___/article/details/83214364
版权

链表：

一种链式存储的线性表，用一组地址任意的存储单元存放线性表的 数据元素，称存储单元为一个节点。链表可以分为带头结点的单链表和不带头结点的单链表。此片文章是不带头结点的单链表

上图为单链表结构，每个节点均有数据域data和指向下一个节点的指针域pNext。

链表优缺点：在执行插入和删除操作是不需要移动元素，但在查询时必须通过头结点进行查询比较麻烦。由于存放元素的地址不连续。因此有可能造成空间浪费。

链表结构c语言描述

typedef int DataType;
typedef struct SList
{
    DataType data;
    struct SList* pNext;

}SList;
函数声明:

void Init(SList **ppHead);//初始化
SList* BuyNewNode(DataType data);//申请新节点
void PushBack(SList **ppHead, DataType data);//头插
void myprintf(SList *ppHead);//打印函数
void DestroyLinkList(SList **ppHead);//销毁
void SListPopBack(SList** pHead);//尾删
void SListPushFront(SList** pHead, DataType data);//头插
void SListPopFront(SList** pHead);//头删

//面试题

void PrintListFromTail2Front(SList* pHead);// 从尾到头打印单链表 

void DeleteListNotTail(SList* pos);// 删除单链表的非尾结点，不能遍历链表 
void InsertPosFront(SList* pos, DataType data);// 在单链表非头结点前插入新节点，要求不能遍历链表 
SList* JosephCircle(SList* pHead, int M);// 用单链表模拟实现约瑟夫环 
void BubbleSort(SList* pHead);// 用冒泡排序对单链表进行排序 
SList* FindMiddleNode(SList* pHead);// 查找单链表的中间结点，要求只能遍历一次链表
SList* FindLastKNode(SList* pHead, int K);// 查找单链表的倒数第K个结点，要求只能遍历一次链表 
void ReverseList(SList** pHead);// 单链表的逆置尾插
SList* ReverseListOP(SList* pHead);//头插
SList* MergeList(SList* pHead1, SList* pHead2);// 合并两个有序链表，合并成功后依然有序 
SList* HasListCircle(SList* pHead);// 检测单链表是否带环 
int GetCircleLen(SList* pHead);// 求环的长度
SList* GetEnterNode(SList* pHead, SList* pMeetNode);// 求环的入口点 
int IsListCross(SList* pHead1, SList* pHead2);// 判断两个单链表是否相交(链表不带环) 
SList* GetCrossNode(SList* pHead1, SList* pHead2);// 若相交，求交点
int IsListCrossWithCircle(SList* pHead1, SList* pHead2);// 检测两个链表是否相交，链表可能带环

函数的实现：

#include"SList.h"
#include<stdio.h>
#include<malloc.h>
void Init(SList **ppHead)//初始化
{
    *ppHead = NULL;
}
SList* BuyNewNode(DataType data)//申请新节点
{
    SList *pNewNode = (SList*)malloc(sizeof(SList));
    if (pNewNode == NULL)
    {
        assert(0);
        return NULL;
    }
    assert(pNewNode);
    pNewNode->data = data;
    pNewNode->pNext = NULL;
    return pNewNode;


}
void PushBack(SList **ppHead, DataType data)//尾插
{
    SList *pNewNode = BuyNewNode(data);//如果头结点不存在用申请的节点来创建头结点
    if (*ppHead == NULL)
    {
        *ppHead = pNewNode;

    }
    else
    {
        SList *pCur = *ppHead;
        while (pCur->pNext != NULL)
        {
            pCur = pCur->pNext;
        }
        pCur->pNext = pNewNode;
        pNewNode->pNext = NULL;
    }

}
void DestroyLinkList(SList **ppHead)//销毁
{
    SList *Cur = *ppHead;
    SList *Pre = NULL;
    while (Cur)

    {
        Pre = Cur->pNext;
        free(Cur);
        Cur = Pre;
        
    }
    ppHead = NULL;


}
void SListPopBack(SList** ppHead)//尾删
{
    assert(ppHead);
    if (*ppHead == NULL)
    {
        return;

    }
    SList* cur = *ppHead;
    SList* pre = NULL;
    while (cur->pNext!=NULL)
    {
        pre = cur;
        cur = cur->pNext;

    }
    free(cur);
    cur=NULL;
    pre->pNext = NULL;


}
void SListPushFront(SList** ppHead, DataType data)//头插
{

    SList *pNewNode = BuyNewNode(data);
    if (ppHead == NULL)
    {
        *ppHead = pNewNode;

    }
    else
    {
        pNewNode->pNext = *ppHead;
        *ppHead = pNewNode;
    }

}
void SListPopFront(SList** ppHead)//头删
{
    SList* pDel = NULL;
    assert(ppHead);
    if (NULL == *ppHead)
        return;

    pDel = *ppHead;
    *ppHead = pDel->pNext;
    free(pDel);
    

}
SList* SListFind(SList* pHead, DataType data)//查找某个节点
{
    SList* pCur = pHead;
    while (pCur)
    {
        if (data == pCur->data)
            return pCur;

        pCur = pCur->pNext;
    }

    return NULL;
}

SList* SListBack(SList* pHead)//获取最后一个节点
{
    SList* pPreCur = NULL;
    SList* pCur = pHead;
    while (pCur)
    {
        pPreCur = pCur;
        pCur = pCur->pNext;
    }

    return pPreCur;
}
void PrintListFromTail2Front(SList* ppHead)// 从尾到头打印单链表 
{
    
    if (ppHead != NULL)
    {
        PrintListFromTail2Front(ppHead->pNext);
        printf("%d", ppHead->data);
    }

}
void DeleteListNotTail(SList* pos)// 删除单链表的非尾结点，不能遍历链表
{
    assert(pos);
    if (pos == NULL || pos->pNext == NULL)//该节点和下一个节点不能为空
    {
        return;
    }
    SList*cur = NULL;
    cur = pos->pNext;
    pos->data = cur->data;
    pos->pNext = cur->pNext;
    free(cur);

}void InsertPosFront(SList* pos, DataType data)// 在单链表非头结点前插入新节点，要求不能遍历链表 
{
    SList*pNewNode = NULL;
    if (pos ==NULL)
        return;
    pNewNode = BuyNewNode(pos->data);
    pNewNode->pNext = pos->pNext;
    pos->pNext = pNewNode;
    pos->data = data;
}
SList* JosephCircle(SList* pHead, int M)// 用单链表模拟实现约瑟夫环 
{
    SList*Tail = pHead;
    SList*cur = NULL;
    while (Tail->pNext != NULL)
    {
        Tail = Tail->pNext;

    }
    Tail->pNext =pHead;
    cur = pHead;
    while (cur->pNext != cur)
    {
        int k = M;
        SList*next = NULL;
        while (--k)
            cur = cur->pNext;
        
        next = cur->pNext;//伪删除是指并不是将这个节点删除，而是将该节点的data改为下一个节点的data.
        cur->data = next->data;
        cur->pNext = next->pNext;
        free(next);

    }
    return cur;
}
void BubbleSort(SList* pHead)// 用冒泡排序对单链表进行排序 

    {
        SList* pTailNode = NULL;
        int isChange = 0;
        if (NULL == pHead || NULL == pHead->pNext)//链表为空或只有一个节点不同排序
            return;

        while (pHead != pTailNode)//排序轮数
        {
            SList* pPre = pHead;
            SList* pCur = pPre->pNext;
            isChange = 0;

            // 冒泡方法
            while (pCur != pTailNode)//每一轮需要进行的排序次数
            {
                if (pPre->data > pCur->data)
                {
                    DataType temp = pPre->data;
                    pPre->data = pCur->data;
                    pCur->data = temp;
                    isChange = 1;
                }

                pPre = pCur;
                pCur = pCur->pNext;
            }

            if (!isChange)//如果次序正常则不进行这次排序
                return;

            pTailNode = pPre;//当一遍排序结束后最后一个节点不同在排序将为指针向前移动
        }
}
SList* FindMiddleNode(SList* pHead)// 查找单链表的中间结点，要求只能遍历一次链表
{
    SList *slow = pHead;
    SList*fast = pHead;
    while (fast&&fast->pNext)
    {
        slow = slow->pNext;
        fast = fast->pNext->pNext;
    }
    return slow;
}
SList* FindLastKNode(SList* ppHead, int K)// 查找单链表的倒数第K个结点，要求只能遍历一次链表 
{
    SList  *pFast = ppHead;
    SList *pSlow = ppHead;
    if (ppHead == NULL || K <= 0)
        return 0;
    while (--K)
    {
        if (pFast == NULL)
            return NULL;
        pFast = pFast->pNext;
    }
    while (pFast->pNext!=NULL)
    {
        pFast = pFast->pNext;
        pSlow = pSlow->pNext;
    }
    return pSlow;


}
void ReverseList(SList** ppHead)// 单链表的逆置
{
    SList *pCur = NULL;
    SList *pPre = NULL;
    SList *pNext = NULL;
    pCur = *ppHead;
    while (pCur)
    {
        pNext = pCur->pNext;
        pCur->pNext = pPre;//将取下来的节点直接连在pPre的前面
        pPre = pCur;
        pCur = pNext;

    }
    *ppHead = pPre;
}
SList* MergeList(SList* pHead1, SList* pHead2)// 合并两个有序链表，合并成功后依然有序
{
    SList *pNewNode = NULL;
    SList *pTail = NULL;//用来保证新节点不用动因此先插一个节点；
    SList*pL1 = pHead1;
    SList*pL2 = pHead2;
    if (pHead1 == NULL)
        return pHead2;
    if (pHead2 == NULL)
        return pHead2;
    if (pL1->data <= pL2->data)//先存放一个节点
    {
        pNewNode = pTail = pL1;
        pL1 = pL1->pNext;
    }
    else
    {
        pNewNode = pTail = pL2;
        pL2 = pL2->pNext;
    }
    while (pL1&&pL2)
    {
        if (pL1->data <= pL2->data)
        {
             pTail->pNext = pL1;
            pL1 = pL1->pNext;
        }
        else
        {
             pTail->pNext= pL2;
            pL2 = pL2->pNext;
        }
        pTail = pTail->pNext;
        
    }
    if (pL1)
        pTail->pNext = pL1;
    else
        pTail->pNext = pL2;
    return pNewNode;
}

SList* HasListCircle(SList* ppHead)// 检测单链表是否带环 
{
    SList *pFast = ppHead;
    SList *pSlow = ppHead;
    while (pFast&&pFast->pNext)//肯定会在环内相遇
    {
        pFast = pFast->pNext->data;
        pSlow = pSlow->pNext;
        if (pFast == pSlow)
            return pFast;
    }
    return NULL;
}
int GetCircleLen(SList* pMeetNode)// 求环的长度
{
    int count = 1;
    SList *pCur = pMeetNode;
    if (pMeetNode == NULL)
        return 0;
    while (pCur->pNext != pMeetNode)
    {
        count++;
        pCur = pCur->pNext;
    }
    return count;

}
SList* GetEnterNode(SList* ppHead, SList* pMeetNode)// 求环的入口点 
{
    SList *pH = ppHead;
    SList *pM = pMeetNode;
    if (ppHead == NULL || pMeetNode == NULL)
        return NULL;
    while (pH!=pM)//相遇点和从头开始的节点一定会在入口点相交
    {
        pH = pH->pNext;
        pM = pM->pNext;
    }
    return pM;
}
int IsListCross(SList* pHead1, SList* pHead2)// 判断两个单链表是否相交(链表不带环) 
{
    SList*pH1 = pHead1;
    SList*pH2 = pHead2;
    if (pHead1 == NULL || pHead2 == NULL)
        return 0;
    while (pH1)
        pH1 = pH1->pNext;
    while (pH2)
        pH2 = pH2->pNext;
    return pH1 == pH2;

}
SList* GetCrossNode(SList* pHead1, SList* pHead2)// 若相交，求交点
{
    SList *pH1 = pHead1;
    SList *pH2 = pHead2;
    int count = 0;
    int size1 = 0;
    int size2 = 0;
    while (pH1 != NULL)
    {
        pH1 = pH1->pNext;
        size1++;
    }
    while (pH2 != NULL)
    {
        size2++;
        pH2 = pH2->pNext;
    }
    count = size1 - size2;
    if (count > 0)
    {
        while (count--)
            pH1 = pH1->pNext;
    }
    else
    {
        while (count++)
            pH2 = pH2->pNext;
    }
    while (pH1 != pH2)
    {
        pH1 = pH1->pNext;
        pH2 = pH2->pNext;

    }
    return pH1;
}
int IsListCrossWithCircle(SList* pHead1, SList* pHead2)
{
    SList* pMeetNode1 = NULL;
    SList* pMeetNode2 = NULL;
    if (NULL == pHead1 || NULL == pHead2)
        return 0;

    pMeetNode1 = HasListCircle(pHead1);
    pMeetNode2 = HasListCircle(pHead2);
    if (NULL == pMeetNode1 && NULL == pMeetNode2)//不带环相交
    {
        SList* pTailNode1 = pHead1;
        SList* pTailNode2 = pHead2;
        while (pTailNode1->pNext)
            pTailNode1 = pTailNode1->pNext;

        while (pTailNode2->pNext)
            pTailNode2 = pTailNode2->pNext;

        if (pTailNode1 == pTailNode2)
            return 1;
    }
    else if (pMeetNode1 && pMeetNode2)//带还相交
    {
        SList* pCur = pMeetNode1;
        while (pCur->pNext != pMeetNode1)
        {
            if (pCur == pMeetNode2)
                return 2;

            pCur = pCur->pNext;
        }

        if (pCur == pMeetNode2)
            return 2;
    }

    return 0;
}
void myprintf(SList *ppHead)


{
    SList *pCur = ppHead;
    while (pCur != NULL)
    {
        printf("%d", pCur->data);
        pCur = pCur->pNext;
    }
}

 


 

chenyifei___
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【头歌】单链表的基本操作
qq_39977056的博客
01-23 1万+
由于单链表中每个结点的存储地址是存放在其前趋结点的指针域中的，而第一个结点无前趋，头指针L指向第一个结点，对于整个单链表的读取必须从头指针开始，同时，由于单链表中最后一个结点的指针域为“空”（NULL），没有直接后继元素，对于整个单链表的读取必须在尾结点结束。要在带头结点的单链表L中删除第i个结点，则同样要先找到第i-1个结点，使p指向第i-1个结点，使q指向第i个结点，然后令第i-1个结点的指针域指向第i+1个结点，而后删除q指向的第i个结点并释放结点空间。= NULL时，才能进行删除结点的操作。
单链表 简单题（单链表基本操作）
菇凉小伙de博客
10-08 1296
题目描述： 有一个带头结点的单链表L=（a1,b1,a2,b2,......an,bn),设计一个算法将其拆分成两个带头结点的单链表L1和L2，其中L1=（a1,a2,a3...an),L2=(b1,b2,b3....bn),要求L1使用L的头结点。 解题思路： 利用原单链表L中的所有节点通过改变指针域重组成两个单链表L1和L2，由于L1中节点的相对顺序与L中的相同，所以采用尾插法建立单链表...
数据结构实验之单链表----单链表的基本操作
2201_75867204的博客
08-22 2388
单链表
建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的 值为 NULL
Shadow_Kerry
05-26 7702
#include &lt;iostream&gt;  #include &lt;cstdlib&gt;  #include &lt;cstdio&gt;    using namespace std;    typedef struct node  {      int data;      struct node *pre;      struct node *next;  } LinkList...
链表经典练习题
热门推荐
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
单链表的基本操作(实验)
10-13
【实验要求】 （1） 从键盘读入一组整数，按输入顺序形成单链表。并将创建好的单链表元素依次打印在屏幕上。（注意：选择头插法或者尾插法！...（4） 每种操作结束后，都能在屏幕上打印出此时单链表元素的遍历结果。
数据结构实验二（单链表基本操作）题目和源程序
04-02
1．编写程序完成单链表的下列基本操作： (1)初始化单链表La。 (2)在La中第i个元素之前插入一个新结点。 (3)删除La中的第i个元素结点。 (4)在La中查找某结点并返回其位置。 (5)打印输出La中的结点元素值。 2 ....
java单链表的基本操作 单链表练习题.zip
最新发布
12-20
在这个"java单链表的基本操作 单链表练习题.zip"压缩包中，我们可以预见到包含了一个名为"linked-list-master"的项目，它很可能是为了帮助学习者通过实践来理解和掌握单链表的各种操作。下面，我们将深入探讨单链表...
单链表的插入删除 遍历等操作
12-05
总之，理解和熟练掌握单链表的插入、删除和遍历等基本操作是编程初学者的重要任务，这将有助于进一步学习更复杂的数据结构和算法。通过实际编写和调试C语言的代码，可以加深对这些概念的理解，并提高编程技能。
cpp代码-单链表的操作-oj
07-14
首先，让我们详细了解一下单链表的基本操作： 1. **创建链表**：在C++中，我们可以通过定义一个结构体或类来表示链表的节点，通常包含数据域和指针域。例如： ```cpp struct ListNode { int val; // 节点值 ...
单双向循环链表的转换（C语言）
03-09
数据结构C语言版（单双向循环链表的转换）
leetcode链表面试题目集锦
xiangxianghehe的博客
08-16 1万+
本文系转载,出处信息 作者：Mr希灵 链接：https://www.jianshu.com/p/f0c3235369ac 來源：简书 1.链表 链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。 1.1定义 链...
hrbust 基础数据结构——单链表（1）
weixin_30588675的博客
11-12 410
Description 输入n个整数，先按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和完成删除后的单链表。 Input 第一行输入数据个数n； 第二行依次输入n个整数； 第三行输入欲删除数据m。 Output 第一行输出原...
单链表的几个题目题解
m0_63185171的博客
07-07 278
主要描述了自己在学习单链表的时候遇到的题目的讲解
《数据结构》第五版：上机题目之单链表的增删改查
PPY的博客
10-31 165
循环单链表： 头文件：“clinklist.h” #pragma once #include<stdio.h> #include<malloc.h> typedef int Elemtype; typedef struct LNode { Elemtype data; struct LNode* next; }LinkNode; void InitList(LinkNode *&L) { L = (LinkNode*)malloc(sizeof(LinkNode));
链表操作例题
weixin_43872379的博客
03-29 306
反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] def reverseList(self, head: ListNode) -> ListNode: l=None while head:#如果该节点存在 f=head.next #保存该
【单链表四道经典例题（必会）】
weixin_60053402的博客
04-01 1987
这几道题都是面试的笔试中经常出现的题，也比较经典，必须学会！
单链表的基本操作及各操作对应典题
YGQ_qq_1435471912
02-16 665
在单链表中，我们假定每一个节点（结构体）用Linklist表示，一个节点包含一个储存元素的数据域（用名字为data的一维数组表示）和储存后继元素位置的指针域（用next表示）。节点声明如下 typedef struct node { int data[maxsize]; //数据域 struct node *next; //指针域指向后继结点 }Linklist; //节点 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值