数据结构之链表的简单操作及相关面试题

最新推荐文章于 2022-06-24 23:04:49 发布
最新推荐文章于 2022-06-24 23:04:49 发布
阅读量171 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mmwwxx123/article/details/80738494
版权

简单实现链表的基本操作：初始化，销毁，增删改查等操作。
SlistNode.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#pragma warning(disable:4996)

typedef int DataType;
typedef struct SlistNode
{
    struct SlistNode *pNext;//指向链表中下一个结点
    DataType data;//当前结点中所保存的元素
}SlistNode;

void Print(SlistNode *pFirst);//打印

void SlistInit(SlistNode **ppFirst);//初始化
void SlistDestroy(SlistNode **ppFirst);//销毁

void PushBack(SlistNode **ppFirst, DataType data);//尾插
void PushFront(SlistNode **ppFirst, DataType data);//头插
void Insert(SlistNode **ppFirst,SlistNode *pos, DataType data);//指定位置插入


void PopFront(SlistNode **ppFirst);//头删
void PopBack(SlistNode **ppFirst);//尾删
void Erase(SlistNode **ppFirst, SlistNode *pos);//任意结点删

SlistNode *Find(SlistNode *pFirst, DataType data);//查找，找到返回遇到的第一个结点的地址，没找到，返回NULL

void Remove(SlistNode **pFirst, DataType data);//根据数据删除，删除遇到的第一个结点
void RemoveAll(SlistNode **pFirst, DataType data);//根据数据删除，删除遇到的所有结点

SlistNode.c

#include"SlistNode.h"

void Print(SlistNode *pFirst)//打印
{
    SlistNode *pNode;
    for (pNode = pFirst; pNode; pNode = pNode->pNext)
    {
        printf("%d-> ", pNode->data);
    }
    printf("NULL\n");
}
void SlistInit(SlistNode **ppFirst)//初始化
{
    assert(ppFirst);
    *ppFirst = NULL;
}
SlistNode * CreateNewNode(int data)//创造新节点
{
    SlistNode *pNewNode = (SlistNode *)malloc(sizeof(SlistNode));
    assert(pNewNode);
    pNewNode->data = data;
    pNewNode->pNext = NULL;
    return pNewNode;
}
void PushBack(SlistNode **ppFirst, DataType data)//尾插
{
    assert(ppFirst);
    SlistNode *pNewNode=CreateNewNode(data);
    if (*ppFirst == NULL)
    {
        *ppFirst = pNewNode;
        return;
    }
    SlistNode *pNode;
    pNode =  *ppFirst;
    while (pNode->pNext != NULL)
    {
        pNode = pNode->pNext;
    }
    pNode->pNext = pNewNode;
}
void PushFront(SlistNode **ppFirst, DataType data)//头插
{
    assert(ppFirst);
    SlistNode *pNewNode=CreateNewNode(data);
    pNewNode->pNext = *ppFirst;
    *ppFirst = pNewNode;

}
void Insert(SlistNode **ppFirst, SlistNode *pos, DataType data)//指定位置插入
{
    assert(ppFirst);
    SlistNode *pNode;
    pNode = *ppFirst;
    if (pos == *ppFirst)//判断第一个结点是否为要找的结点
    {
        PushFront(ppFirst, data);//是，就为头插
        return;
    }
    while (pNode->pNext != pos)
    {
        pNode = pNode->pNext;
    }
    SlistNode *pNewNode = CreateNewNode(data);
    pNode->pNext = pNewNode;
    pNewNode->pNext = pos;
}
SlistNode *Find(SlistNode *pFirst, DataType data)//查找，找到返回遇到的第一个结点的地址，没找到，返回NULL
{
    SlistNode *pNode;
    for (pNode = pFirst; pNode; pNode = pNode->pNext)
    {
        if (pNode->data = data)
        {
            return pNode;
        }
    }
    return NULL;
}
void PopFront(SlistNode **ppFirst)//头删
{
    assert(ppFirst);
    SlistNode *pOldNode = *ppFirst;
    *ppFirst = (*ppFirst)->pNext;
    free(pOldNode);
}
void PopBack(SlistNode **ppFirst)//尾删
{
    assert(ppFirst);
    assert(*ppFirst);
    if ((*ppFirst)->pNext == NULL)
    {
        free(*ppFirst);
        *ppFirst = NULL;
        return;
    }
    SlistNode *pNode = *ppFirst;
    while (pNode->pNext->pNext != NULL)
    {
        pNode = pNode->pNext;
    }
    free(pNode->pNext);
    pNode = pNode->pNext;
}
void Erase(SlistNode **ppFirst, SlistNode *pos)//任意结点删
{
    assert(ppFirst);
    assert(*ppFirst);
    if ((*ppFirst == pos))
    {
        PopFront(ppFirst);//头删
        return;
    }
    SlistNode *pCur = *ppFirst;
    while (pCur->pNext != pos)
    {
        pCur = pCur->pNext;
    }
    pCur->pNext = pos->pNext;
    free(pos);
}
void SlistDestroy(SlistNode **ppFirst)//销毁
{
    assert(ppFirst);
    SlistNode *pNode;
    SlistNode  *pNext;
    pNode = *ppFirst;
    while (pNode != NULL)
    {
        pNext = pNode->pNext;
        free(pNode);
        pNode = pNext;
    }
    *ppFirst = NULL;
}
void Remove(SlistNode **ppFirst, DataType data)//根据数据删除，删除遇到的第一个结点
{
    SlistNode *pFound = Find(*ppFirst, data);
    if (pFound != NULL)
    {
        Erase(ppFirst, pFound);
    }
}
//void RemoveAll(SlistNode **ppFirst, DataType data)//根据数据删除，删除遇到的所有结点
{
    SlistNode *pNode = *ppFirst;
    SlistNode *pNext;
    while (pNode->pNext)
    {
        if (pNode->pNext->data == data)
        {
            pNext = pNode->pNext;
            pNode->pNext = pNode->pNext->pNext;
            free(pNext);
        }
        else
        {
            pNode = pNode->pNext;
        }
    }
    if ((*ppFirst)->data == data)
    {
        PopFront(ppFirst);
    }
}

有些链表常考的面试题，分别为：

  1. 倒叙打印链表 
void ReversePrint(SlistNode *pFirst)
{
    SlistNode *pNode = pFirst;
    if (pNode->pNext)
    {
        ReversePrint(pNode->pNext);
    }
    printf("%d->", pNode->data);
}
  1. 逆置链表
SlistNode * ReverseList(SlistNode *pFirst)
{
    /*SlistNode *p1 = NULL;
    SlistNode *p2 = pFirst;
    SlistNode *p3 = pFirst->pNext;
    while (p2)
    {
        p2->pNext = p1;
        p1= p2;
        p2 = p3;
        if (p3 != NULL)
        {
            p3 = p3->pNext;
        }

    }
    return p1;
*/

    SlistNode *pNewFirst = NULL;
    DataType data;
    while (pFirst != NULL)
    {
        data = pFirst->data;
        PopFront(&pFirst);//头删
        PushFront(&pNewFirst, data);//头插
    }
    return pNewFirst;
}
  1. 删除非尾无头链表
void RemoveNodeNotTail(SlistNode *pos)
{
    assert(pos);
    SlistNode *pNode = pos->pNext;
    pos->pNext = pNode->pNext;
    pos->data = pNode->data;
    free(pNode);
}
  1. 无头链表前插入
void InsertNoHead(SlistNode *pos, int data)
{
    SlistNode *pNode = (SlistNode *)malloc(sizeof(SlistNode));
    assert(pNode);
    pNode->data = pos->data;

    pNode->pNext = pos->pNext;
    pos -> pNext=pNode;
    pos->data = data;
}
  1. 约瑟夫环 
SlistNode * JocephCircle(SlistNode *pFirst, int k)
{
    SlistNode *pNode = pFirst;
    SlistNode *pRev = NULL;
    int i = 0;
    //用单链表构建出环
    while (pNode->pNext)
    {
        pNode = pNode->pNext;
    }
    pNode ->pNext= pFirst;
    //开始循环
    pNode = pFirst;
    while (pNode->pNext != pNode)
    {
        for ( i = 0; i < k - 1; i++)
        {
            pRev = pNode;
            pNode = pNode->pNext;

        }
        pRev->pNext = pNode->pNext;
        free(pNode);
        pNode = pRev->pNext;    
    }
    return pNode;


}
  1. 冒泡排序 
void BubbleSort(SlistNode *pFirst)
{
    SlistNode * pCur = NULL;
    SlistNode *tail = NULL;
    assert(pFirst);
    pCur = pFirst;
    if ((pFirst== NULL) || (pFirst->pNext == NULL))
    {
        return;
    }
    while (pCur != tail)     //当尾指针不等于头指针时进行冒泡
    {
        while (pCur->pNext != tail)   //控制pCur指针最后到的位置是倒数第二个节点
        {

            if (pCur->data >pCur->pNext->data)
            {
                int tmp = pCur->data;
                pCur->data = pCur->pNext->data;
                pCur->pNext->data = tmp;
            }
            pCur = pCur->pNext;
        }
        tail = pCur;
        pCur = pFirst;
    }
    return;

}
  1. 合并两个有序链表 
SlistNode * MergeOrderedList(SlistNode *p1First, SlistNode *p2First)
{
    SlistNode *p1 = p1First;
    SlistNode *p2 = p2First;
    SlistNode *pNew = NULL;
    //两个都不为空
    while (p1 != NULL &&p2 != NULL)
    {
        if (p1->data < p2->data)
        {
            PushBack(&pNew, p1->data);
            p1 = p1->pNext;
        }
        else
        {
            PushBack(&pNew, p2->data);
            p2 = p2->pNext;
        }
    }
    //有一个为空了
    SlistNode *pNotempty = p1;//假设p1不为空
    if (p1 == NULL)
    {
        pNotempty = p2;
    }
    while (pNotempty)
    {
        PushBack(&pNew, pNotempty->data);
        pNotempty = pNotempty->pNext;
    }
    return pNew;

}
  1. 遍历一次，找到中间结点 
SlistNode * FindMid(SlistNode *pFirst)
{
    SlistNode *pFast = pFirst;
    SlistNode *pSlow = pFirst;
    while (1)
    {
        pFast = pFast->pNext;
        if (pFast == NULL)
        {
            break;
        }
        pFast = pFast->pNext;
        if (pFast == NULL)
        {
            break;
        }
        pSlow = pSlow->pNext;
    }
    return pSlow;
}
  1. 遍历一次，找到倒数第 k 个结点（k从1开始）
SlistNode * FindK(SlistNode *pFirst, int k)
{
    SlistNode *pSlow = pFirst;
    SlistNode *pFast = pFirst;
    if (NULL == pFirst || k< 0)
        return NULL;
    //让pFast先走K步
    while (k--)
    {
        if (NULL == pFast)//K大于节点个数
            return NULL;
        pFast = pFast->pNext;
    }
    //两指针同时往后走
    while (pFast)
    {
        pFast = pFast->pNext;
        pSlow = pSlow->pNext;
    }
    return pSlow;

}
  1. 遍历一次，删除倒数第 k 个结点（k从1开始），不能用替换删除法 
void RemoveK(SlistNode *pFirst, int k)
{
    SlistNode *pSlow = pFirst;
    SlistNode *pFast = pFirst;
    SlistNode *pPre = NULL;
    if (NULL == pFirst || k< 0)
        return NULL;
    //让pFast先走K步
    while (k--)
    {
        if (NULL == pFast)//K大于节点个数
            return NULL;
        pFast = pFast->pNext;
    }
    //两指针同时往后走
    while (pFast)
    {
        pPre = pSlow;
        pFast = pFast->pNext;
        pSlow = pSlow->pNext;
    }
    //删除
    pPre->pNext = pSlow->pNext;
    free(pSlow);
}

11.复制复杂链表

typedef struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
}RandomListNode;


RandomListNode* Clone(RandomListNode* pHead)
{
    RandomListNode* pNode;
    RandomListNode* pOldRandom;
    RandomListNode* pNewNode;
    RandomListNode* pNewRandom;
    //复制结点
    for (pNode = pHead; pNode; pNode = pNode->next->next)
    {
        pNewNode = (RandomListNode *)malloc(sizeof(RandomListNode));
        pNewNode->label = pNode->label;
        pNewNode->next = pNode->next;
        pNewNode->random = NULL;
        pNode->next = pNewNode;
    }
    //复制结点random
    for (pNode = pHead; pNode; pNode = pNode->next->next)
    {
        pNewNode = pNode->next;
        pOldRandom = pNode->random;
        if (pOldRandom != NULL)
        {
            pNewRandom = pOldRandom->next;
            pNewNode->random = pNewRandom;
        }
    }
    //拆链表
    RandomListNode *pNewFirst = pHead->next;
    for (pNode = pHead; pNode; pNode = pNode->next)
    {
        pNewNode = pNode->next;
        pNode->next = pNewNode->next;
        if (pNode->next != NULL)
        {
            pNewNode->next= pNode->next->next;
        }
        else
        {
            pNewNode->next = NULL;
        }
    }
    return pNewFirst;

}
Niya-m
关注
专栏目录
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6799
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表相关的试题连载
梦否
10-20 240
链表相关的试题连载 说明 这是在复习考研数据结构时候的试题的编写和整理。包含王道和天勤。主要是对编程题的练习，不涉及填空题等。 这里首先给出的是链表的定义相关的自定义头文件： - 数据结构格式： lianbiao.h 在编写的cpp文件中，#include “lianbiao.h”中引入就可以了。 #ifndef CRYU_H //如果没有定义CRYU_H #define CRYU_H /...
数据结构| |链表的基本操作以及链表的面试题(总概括)
凯的博客
08-16 242
这是链表的基本操作以及链表的面试题的全部内容，可供大家下载哟！ 里面也写好了测试函数，大家可以看一下，测试一下！ 直接上代码： 头文件： #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include &lt;stdio.h&gt; #include &lt;assert.h&gt; #include &lt;stdlib.h&gt; #i...
链表的数据结构
HelloJFS的博客
12-30 341
链表结构的定义：链表应该由三部分部分组成： 结点： 结点由结点的值和指针（每个独立的结点只申明指针，并不指向具体的对象） 表头 结点指针指向的对象 链表定义一个大类： 表头（变量） 结点（类） 尾部添加结点（方法）：结点的值添加在哪个结点的后面，当然新增加的结点只能在最后： 添加结点方法的描述： 新定义一个结点； 判断有没有头结点，如果没有头结点，就将新结点作为头结点； 如果有头结点，就取出头结点，
链表的常见数据结构及题目
KevinJune的博客
06-24 471
目录1 哈希表的简单介绍2 有序表的简单介绍3 链表的节点结构4 面试时链表解题的方法论5 判断一个链表是否为回文结构6 将单向链表按某值划分成左边小、中间相等、右边大的形式7 复制含有随机指针节点的链表8 两个单链表相交的一系列问题1. 哈希表在使用层面上可以理解为一种集合结构2. 如果只有key，没有伴随数据value，可以使用HashSet结构（C++中叫UnOrderedSet）3. 如果既有key，又没有伴随数据value，可以使用HashMap结构（C++中叫UnOrderedMap）4. 有无
数据结构之链表构建及应用
sdshdutx的博客
10-09 409
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置)，相当于车厢与单向车链组成： 1.定义单链 package List; //链节点，有数据域和指针域构成 public class Node { public long data; //数据域 public...
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
Java常见数据结构面试题（带答案）
08-29
"Java常见数据结构面试题（带答案）" 以下是对Java常见数据结构面试题的...本篇文章主要介绍了Java常见数据结构面试题，涵盖了栈、队列、链表、线性表、树、算法、数据结构等知识点，希望对广大的程序爱好者有所帮助。
C语言链表相关面试题.zip
最新发布
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
[java版数据结构和算法系列之二]链表之一 –【单链】—手把手带你模拟链表的实现【内含BAT链表面试题实现】
12-21
链表是一种线性数据结构，它的元素（节点）在内存中不是连续存储的，而是通过每个节点的指针域相互连接。链表主要分为三类：单链表、双链表和环状链表。 1. **单链表**：每个节点包含一个数据域和一个指针域，指针...
【数据结构】链表的原理及java实现
热门推荐
简约人生的博客
04-20 11万+
一：单向链表基本介绍链表是一种数据结构，和数组同级。比如，Java中我们使用的ArrayList，其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高，但是插入和删除时优势明显。下面对单向链表做一个介绍。单向链表是一种线性表，实际上是由节点（Node）组成的，一个链表拥有不定数量的节点。其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它
数据结构简答题汇总
小白成长记
05-12 2万+
面对即将要参加的考研复试，数据结构是必考科目，希望以下能派上用场 1.算法的时间复杂度： 答：在程序中反复执行的语句的执行次数被称为语句的频度，时间复杂度就是所有语句频度之和的数量级，而所有语句的频度之和与程序最内层循环的频度是同一个数量级，所以算法的时间复杂度是最内层循环的频度的数量级 2.空间复杂度： 答：程序在运行时所占的空间 直接插入排序的空间复杂度是O（1），递归的空间复杂度是O（n） 3.贪心算法、动态规划和分治算法 答：贪心算法是指从上到下，每次都求解局部最优解的算法，特点是每次求解最优解，但
数据结构简答题期末复习
烟敛寒林的博客
12-26 1万+
1、数据结构定义 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。   2、其逻辑结构的四种关系并画出它们的关系图 集合结构 2.线性结构 3.树形结构 4.图形结构 https://blog.csdn.net/dyw_666666/article/details/82343558   3、数据结构的特性 数组：优点是插入快，如果知道下标，可...
数据结构-链表的经典面试题
y6_xiamo的博客
04-12 1246
在前面的博客中我们对链表做了一些基本操作，所以在此不再赘述。直接来看，有哪些和链表有关的面试题以及如何去实现它们。 1.头文件声明 linklist.h #pragma once typedef char LinkNodeType; typedef struct LinkNode { LinkNodeType data; struct LinkNode *next; ...
数据结构简答题
lollipop的专栏
08-31 4514
jiandat 1．简述数据的逻辑结构和存储结构的区别与联系，它们如何影响算法的设计与实现？ 答：若用结点表示某个数据元素，则结点与结点之间的逻辑关系就称为数据的逻辑结构。数据在计算机中的存储表示称为数据的存储结构。可见，数据的逻辑结构是反映数据之间的固有关系，而数据的存储结构是数据在计算机中的存储表示。尽管因采用的存储结构不同，逻辑上相邻的结点，其物理地址未必相同，但可通过结点的内部信息，找
【数据结构】链表基本操作（增、删、查、改）
waves_K的博客
07-13 402
#pragma once #include<stdio.h> #include<malloc.h> #include<assert.h> #include<stdlib.h> typedef int SListDataType; // 链表中的一个节点 typedef struct Node{ SListDataType value;...
动态内存开辟
mmwwxx123的博客
06-06 432
动态内存开辟 为什么存在动态内存分配？ 因为有时候我们需要的空间大小在程序运行的时候才能知道，那数组的编译时开辟空间的方式就不能满足了。这样就只能用动态开辟了。 动态内存函数 malloc 和 free malloc: void * malloc(size_t size) 这个函数向内存申请一块连续可用的空间，并返回指向这块空间的指针。 若开辟成功，则返回一个指向开辟...
freebsd MySQL 提权_Intel Sysret (CVE-2012-0217)内核提权漏洞
weixin_39896256的博客
02-15 279
*本文中涉及到的相关漏洞已报送厂商并得到修复，本文仅限技术研究与讨论，严禁用于非法用途，否则产生的一切后果自行承担。据闻，是Intel sysret(CVE-2012-0217)硬件设计的小问题，导致可以实现权限提升。故对Windows、Linux和Unix都有影响。之前看到过类似新闻说，Intel提供给微软等厂商的文档是给出了编码规范的，如果根据此规范进行编码，那么就不存在该问题，所以各位cod...
链表面试题精讲：掌握数据结构核心问题
资源摘要信息:"链表是计算机科学中的基础数据结构之一，主要用于存储元素的集合，但与数组不同，链表中的元素在内存中不必连续存放。链表中的每个元素由一个存储数据本身的节点和一个指向下一个元素的引用（在单向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值