（转）问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。

最新推荐文章于 2023-06-27 10:11:28 发布
最新推荐文章于 2023-06-27 10:11:28 发布
阅读量1.4k 收藏 5
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acm_1361677193/article/details/52841836
版权

问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。

p->data = p->next->data;

p->next = p->next->next;

firee(p->next); 

 

链表结点定义如下：

struct ListNode

{

         int       m_nKey;

         ListNode* m_pNext;

};

解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext；

由题意知，pCurrent指向链表的某一个中间节点，因此pCurrent->m_pNext != NULL。

要删除pCurrent指向的节点B很简单，但必须将节点B前后两个节点A和C连接起来，但是单链表节点没有头指针，因此无法追溯到A，也就无法将A和C相连了。

无法删除节点B，但我们可以删除B的后继节点C，并通过pCurrent->m_pNext = pCurrent->m_pNext->m_pNext重新将链表连接起来，而唯一丢失的是节点C的数据项m_nKey。因此，我们只需要将节点C的数据项取代节点B的数据项，然后将真正指向节点C的指针删除即可实现将节点B“删除”！！关键代码如下：

pCurrent->m_pNext = pNext->m_pNext;

pCurrent->m_nKey = pNext->m_nKey;

delete pNext;

完整代码如下：

#include <iostream>

#include <assert.h>

struct ListNode

{

    int m_nKey;

    ListNode* m_pNext;      

};

//参数必须是指向指针的指针，因为要修改指针

//所以要考虑“参数本地拷贝”问题

void InitList(ListNode** pList)

{

     *pList = (ListNode*)malloc(sizeof(ListNode));

     (*pList)->m_pNext = NULL;

}

//第一个参数不必是指向指针的指针，因为函数内只修改指针指向的数据

//所以不用担心“参数本地拷贝”问题

void InsertList(ListNode* pList, int data)

{

    ListNode* pNewNode = (ListNode*)malloc(sizeof(ListNode));

    pNewNode->m_nKey = data;

    pNewNode->m_pNext = pList->m_pNext;

    pList->m_pNext = pNewNode;

}

//核心算法

void DeleteRandomNode(ListNode* pCurrent)

{

    assert(pCurrent != NULL);

    ListNode* pNext = pCurrent->m_pNext;

    if(pNext != NULL)

    {

        pCurrent->m_pNext = pNext->m_pNext;

        pCurrent->m_nKey = pNext->m_nKey;

        delete pNext;      

                   pNext = NULL;

    }    

}

//打印链表元素

void PrintListNormally(ListNode* pListHead)

{

    ListNode* pTempNode = pListHead->m_pNext;

    while(pTempNode != NULL)

    {

        std::cout<<pTempNode->m_nKey<<std::endl;

        pTempNode = pTempNode->m_pNext;            

    }    

}

int main()

{

    ListNode* pHead = NULL;

    InitList(&pHead);

    for(int i=9; i>=0; i--)

    {

        InsertList(pHead,i);       

    }

    PrintListNormally(pHead);

    ListNode* pNext = pHead->m_pNext->m_pNext; //删除第个元素

    DeleteRandomNode(pNext);

    PrintListNormally(pHead);

    system("pause");

    return 0;   

}

=======================================================

扩展题目：给定链表的头指针和一个结点指针，在O(1)时间删除该结点。链表结点的定义如下：

struct ListNode

{

         int        m_nKey;

         ListNode*  m_pNext;

};

函数的声明如下：

void DeleteNode(ListNode* pListHead, ListNode* pToBeDeleted);

分析：这是一道广为流传的Google面试题，能有效考察我们的编程基本功，还能考察我们的反应速度，更重要的是，还能考察我们对时间复杂度的理解。

在链表中删除一个结点，最常规的做法是从链表的头结点开始，顺序查找要删除的结点，找到之后再删除。由于需要顺序查找，时间复杂度自然就是O(n) 了。

我们之所以需要从头结点开始查找要删除的结点，是因为我们需要得到要删除的结点的前面一个结点。我们试着换一种思路。我们可以从给定的结点得到它的下一个结点。这个时候我们实际删除的是它的下一个结点，由于我们已经得到实际删除的结点的前面一个结点，因此完全是可以实现的。当然，在删除之前，我们需要需要把给定的结点的下一个结点的数据拷贝到给定的结点中。此时，时间复杂度为O(1)。

上面的思路还有一个问题：如果删除的结点位于链表的尾部，没有下一个结点，怎么办？我们仍然从链表的头结点开始，顺便遍历得到给定结点的前序结点，并完成删除操作。这个时候时间复杂度是O(n)。

那题目要求我们需要在O(1)时间完成删除操作，我们的算法是不是不符合要求？实际上，假设链表总共有n个结点，我们的算法在n-1总情况下时间复杂度是O(1)，只有当给定的结点处于链表末尾的时候，时间复杂度为O(n)。那么平均时间复杂度[(n-1)*O(1)+O(n)]/n，仍然为O(1)。

基于前面的分析，我们不难写出下面的代码。

核心参考代码：

//核心算法

//pListHead是链表头指针，pCurrent是要删除的节点指针

void DeleteRandomNode(ListNode* pListHead, ListNode* pCurrent)

{

    assert(pCurrent != NULL || pListHead != NULL);

    if(pCurrent->m_pNext != NULL) //要删除的节点不是最后一个节点

    {

        ListNode* pNext = pCurrent->m_pNext;

        pCurrent->m_nKey = pNext->m_nKey;

        pCurrent->m_pNext = pNext->m_pNext;

        delete pNext;

        pNext = NULL;                   

    }

    else //要删除的节点是链表中最后一个节点

    {

        ListNode* pNode = pListHead;

        while(pNode->m_pNext != pCurrent) //得到要删除节点的前继节点

        {

            pNode = pNode->m_pNext;                    

        }

        pNode->m_pNext = NULL;

        delete pCurrent;

        pCurrent = NULL;

    }

}

完整的代码只需替换第一题的相应函数，并在main函数调用中做相应修改即可。

值得注意的是，为了让代码看起来简洁一些，上面的代码基于两个假设：（1）给定的结点的确在链表中；（2）给定的要删除的结点不是链表的头结点。不考虑第一个假设对代码的鲁棒性是有影响的。至于第二个假设，当整个列表只有一个结点时，代码会有问题。但这个假设不算很过分，因为在有些链表的实现中，会创建一个虚拟的链表头，并不是一个实际的链表结点。这样要删除的结点就不可能是链表的头结点了。当然，在面试中，我们可以把这些假设和面试官交流。这样，面试官还是会觉得我们考虑问题很周到的。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.NET/ACE1985/archive/2010/08/06/5793287.aspx


acm_1361677193
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现单链表节点的删除（不带头结点）
乞力马扎罗的雪CYF的博客
02-25 1万+
对链表节点进行增删改查是最基本的操作，这篇博客将会来实现对节点的删除。其他的操作可参考《C语言实现链表的基本操作》这篇博客。删除某个节点有两个类型：（1）删除i某个位置的节点；（2）判断x值是否在链表中，若存在则删除该节点；实例代码已经上传至 https://github.com/chenyufeng1991/DeleteLinkedList 。核心代码如下： //删除pos位置的节点 Node
c语言将一个已知头结点的单链表逆序_C语言实现单链表反转
weixin_35323550的博客
01-16 1141
一、理解指针看懂链表的结构并不是很难，但是一旦把它和指针混在一起，就很容易让人摸不着头脑。所以，要想写对链表代码，首先就要理解好指针。有些语言有“指针”的概念，比如 C 语言；有些语言没有指针，取而代之的是“引用”，比如 Java、Python。不管是“指针”还是“引用”，实际上，它们的意思都是一样的，都是存储所指对象的内存地址。将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过...
(转)问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。
zhaozhanyong的专栏
02-14 6486
问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。链表结点定义如下： struct ListNode {          int       m_nKey;          ListNode* m_pNext; }; 解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext； 由题意知，pCurrent指向链表的某一个中间节点，因此pCurr
不带头结点的单链表删除任意一个节点
yp18792574062的博客
07-22 8825
#include #include //删除单链表中的任意一个节点，可能是传节点删除，也可能是传节点的值删除 typedef struct _Node { int val; struct _Node* next; }Node,*LinkList; //不带头结点的单链表 void Init(LinkList* list) { (*list) = NULL; } void Creat(Link
没有头结点的单链表如何删除结点
Bruce Lee的专栏
09-09 4443
题目：假设有一个没有头结点的单链表。一个指针指向此单链表中间的一个节点（非第一个节点， 也非最后一个节点）。请将该节点从单链表中删除。 典型的“狸猫换太子”， 若要删除该节点，正常情况下，应该要知道该节点的前面节点的指针，但是由于单链表中没有头结点，所以无法追溯到该节点前面的那个节点，因此，这里采用了“移花接木”的方法。设该节点为B，下一个节点为C。那么，首先将B节点的内容替换为C节点的内容，然
单链表删除指定元素(不带头结点)
weixin_45653543的博客
08-16 1671
单链表删除指定元素
运用c语言编写代码：给定一个头结点为head的非空单链表，返回链表的中间结点。如果有两个中间节点，则返回第二个中间结点。
最新发布
06-12
这种方法利用两个指针，一个快指针每次移动两个节点，一个慢指针每次移动一个节点，当快指针到达链表尾部时，慢指针正好指向中间结点（如果链表长度为奇数）或者距离第二个中间结点一个位置（如果链表长度为偶数）。...
c语言定义一个动态单链表,数据结构 - 动态单链表的实行（C语言）
weixin_39718286的博客
05-22 437
一、什么是单链表？单链表：使用链式存储结构的线性表。单链表中的数据是以结点来表示的，每个结点的构成：数据域(数据元素的映像) + 指针域(指示后继元素存储位置)。如果单链表不做特别说明，一般指的是动态单链表。在 C 语言中可用结构指针来描述单链表：/* 线性表的单链表存储结构 */typedef struct node{ElemType data;struct node *next;}Node, ...
python建立一个节点类_python单链表中如何插入和输出节点？(代码示例)
weixin_29309785的博客
12-28 1583
python单链表中如何插入和输出节点？下面本篇文章就来带大家了解一下单链表是什么，如何对单链表执行的一些非常基本的操作，例如：插入、输出，希望对大家有所帮助。单链表是什么？首先在了解单链表之前，我们必须了解一下节点是什么。节点是链表的构建块，它由两部分组成：1、数据部分：用于包含数据2、地址部分：用于指向下一个节点位置的指针。在单链表中，每个节点的地址部分包含有关下一个节点位置的信息；这形成一系...
可由一个尾指针唯一确定的链表有_课后习题讲解 （数据结构）
weixin_39611070的博客
12-30 1975
第 1 章 绪 论课后习题讲解1. 填空⑴( )是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。【解答】数据元素⑵( )是数据的最小单位，( )是讨论数据结构时涉及的最小数据单位。【解答】数据项，数据元素【分析】数据结构指的是数据元素以及数据元素之间的关系。⑶ 从逻辑关系上讲，数据结构主要分为( )、( )、( )和( )。【解答】集合，线性结构，树结构，图结构⑷ 数据的存储结构主...
数据结构：不带头结点单链表的实现及其一些基本操作.cpp
08-03
不带头结点，不带头结点，不带头结点！ 实现单链表及其一些基本操作函数（不带头结点） 1.头文件包含 2.宏定义及节点类型描述 3.初始化、判断是否为空 4.指定位置插入操作 5.在p节点后插入元素e 6.在p节点前插入元素e 7.删除操作：删除第i个节点，元素值有e传回 8.删除指定节点，不能删除尾部节点 9.按位序查找和按值查找 10.尾插法和头插法建立单链表（包含初始化） 11.表长和简单打印 12.其他简单封装（_fz表示封装） main函数简单测试
数据结构 不带头结点的单链表代码
12-16
数据结构 用不带头结点的单链表实现遍历、插入、查询和删除等功能
从无头单链表中删除节点
一个平凡的技术热爱者
04-27 512
从无头单链表中删除节点的问题分析与算法实现。
C++不使用头结点创建单链表，并实现删除某个结点的功能
qq_38220144的博客
07-13 400
头部声明如下 #include <iostream> #include <malloc.h> using namespace std; typedef int ElemType; typedef struct LNode{ ElemType data;//存放数据元素值 struct LNode *next; }LinkNode; 以下是主函数： ...
不带头结点的单链表（增、删、查、改）
weixin_50603017的博客
01-09 2343
#include <stdio.h> #include <stdlib.h> typedef int ElemType_t; typedef struct Node { ElemType_t data; struct Node* pNext; }Node_t,*pNode_t; /* 函数名: create_list 函数参数：data--第一个结点的数据元素的值 函数返回值： 返回堆区创建出来的第一个结点首地址 函数作用： 创建一个只有一个结点的链表 *.
单链表第一题（递归删除不带头节点链表中指定值）
loveajiao的博客
06-27 348
1.设计一个递归算法，删除不带头节点的单链表L中所有值为X的节点。
删除不带头结点的单链表L中所有值为x的结点（递归实现）
qq_51950769的博客
06-10 1037
为什么这段代码在执行 ls = ls->next 会误以为有断链的感觉
删除无头指针的单链表中的一个节点
qq_37719621的博客
01-11 586
设一个没有头结点指针的单链表,有一指针指向此单链表中一个结点（非第一个，也非最后一个结点），将该结点从单链表中删除，要求时间复杂度O（1）。 没有头指针，则不可能遍历该单链表，况且要求时间复杂度为是常数，则可交换要删除节点（p）和该节点的下一个节点(p->next)的数据域，然后问题转换为删除p节点的下一个节点。 q=p->next; p->data=q->data; p-...
C语言实现单链表（不带头节点）的删除插入完整代码
qq_54628272的博客
02-10 3031
注意：不带头节点的单链表删除插入操作第一个节点的时候都要特殊讨论 以下代码是用C语言实现的完整代码可上机运行 #include<stdio.h> #include<malloc.h> struct linknode { int data; struct linknode* next; }; void init(struct linknode** L) { (*L) = NULL; } void insect(struct linknode** L, int i, ..
 有一个单链表，其头指针为head，编写一个函数计算域为x的个数。
08-13
### 回答1： 以下是C++代码实现： ```c++ int countX(Node* head, int x) { int count = 0; Node* cur = head; while (cur != NULL) { if (cur->data == x) { count++; } cur = cur->next; } return count; } ``` 其中，Node是单链表节点的结构体，包含一个数据域和一个指向下一个节点的指针域。head为头指针，指向单链表的第一个节点。x为要查找的元素。函数遍历单链表，每当遇到一个值为x的节点，计数器count加1。最后返回count即可。 ### 回答2： 题目要求编写一个函数，计算给定单链表中域为x的节点的个数。 首先要理解题目中的一些概念： - 单链表：即链表中的每个节点只包含一个指针域，指向链表中的下一个节点。 - 头指针：链表的头节点的指针。 - 域：链表的每个节点中的数据部分。 根据以上概念，可以编写一个函数来计算域为x的节点的个数。 首先，需要定义链表的节点的结构体： ```C++ struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {} }; ``` 接下来，我们可以定义一个函数来计算域为x的节点的个数： ```C++ int countX(ListNode* head, int x) { int count = 0; ListNode* curr = head; while (curr != nullptr) { if (curr->val == x) { count++; } curr = curr->next; } return count; } ``` 在该函数中，使用一个变量`count`来记录域为x的节点个数，初始值为0。然后，使用一个指针变量`curr`来遍历链表。在遍历过程中，如果当前节点的值等于x，则将`count`加1。最后返回`count`的值，即为域为x的节点的个数。 这是一个简单的链表遍历问题，时间复杂度是O(n)，其中n是链表的长度。 ### 回答3： 假设单链表的每个节点的数据域为value，指针域为next。 解决这个问题的一种方法是，使用一个计数器count，遍历链表的每个节点，如果节点的数据域等于给定的域x，则计数器count加1。代码如下所示： ```python def calculate_count(head, x): count = 0 current = head # current用于指向当前节点，从头节点开始 while current is not None: if current.value == x: count += 1 current = current.next # 指向下一个节点 return count ``` 函数的参数有两个，一个是头指针head，另一个是给定的域x。我们使用一个current指针来遍历链表的每个节点，初始时指向头节点。然后，我们进入一个循环，只要current指针不为空，就执行循环体。 在循环体中，我们首先判断current节点的数据域是否等于给定的域x，如果是，则计数器count加1。然后，我们将current指针向后移动，指向下一个节点，以便继续遍历链表。 最后，我们返回计数器count的值，即为链表中域为x的个数。 注意，上述代码仅为示例，具体实现可能需要根据链表的具体实现方式进行适当修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值