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

最新推荐文章于 2023-07-18 23:18:23 发布
原创 最新推荐文章于 2023-07-18 23:18:23 发布 · 1.4k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍如何在O(1)时间内删除单链表中的指定节点，包括无头指针链表中间节点及有头指针链表任意节点的删除方法。

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

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）给定的要删除的结点不是链表的头结点。不考虑第一个假设对代码的鲁棒性是有影响的。至于第二个假设，当整个列表只有一个结点时，代码会有问题。但这个假设不算很过分，因为在有些链表的实现中，会创建一个虚拟的链表头，并不是一个实际的链表结点。这样要删除的结点就不可能是链表的头结点了。当然，在面试中，我们可以把这些假设和面试官交流。这样，面试官还是会觉得我们考虑问题很周到的。

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


acm_1361677193
关注
C语言实现单链表节点的删除（不带头结点）
乞力马扎罗的雪CYF的博客
02-25 1万+
对链表节点进行增删改查是最基本的操作，这篇博客将会来实现对节点的删除。其他的操作可参考《C语言实现链表的基本操作》这篇博客。删除某个节点有两个类型：（1）删除i某个位置的节点；（2）判断x值是否在链表中，若存在则删除该节点；实例代码已经上传至 https://github.com/chenyufeng1991/DeleteLinkedList 。核心代码如下： //删除pos位置的节点 Node
单链表第一题（递归删除不带头节点链表中指定值）
loveajiao的博客
06-27 431
1.设计一个递归算法，删除不带头节点的单链表L中所有值为X的节点。
#数据结构：编写不带头结点单链表的建立、插入和删除算法
weixin_56561876的博客
05-16 7084
编写不带头结点单链表的建立、插入和删除操作算法。 一、问题描述 编写一个不带头节点的单链表 二、基本要求 1) 建立 2) 插入 3) 删除 三、算法思想 选用不带头结点的单链表，在第一个元素节点前插入节点时头指针的值将改变为指针s的值，在非第一个元素结点的其他结点前插入结点时，改变的是指针->next的值。 删除不带头结点的单链表的第一个元素结点时头指针的值将改变为头指针->next；删除其他节点是，头指针的值不会改变，改变的是指针->next的值。 四、数据结构
(转)问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。
zhaozhanyong的专栏
02-14 6617
问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。链表结点定义如下： struct ListNode {          int       m_nKey;          ListNode* m_pNext; }; 解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext； 由题意知，pCurrent指向链表的某一个中间节点，因此pCurr
不带头结点的单链表删除任意一个节点
yp18792574062的博客
07-22 9017
#include #include //删除单链表中的任意一个节点，可能是传节点删除，也可能是传节点的值删除 typedef struct _Node { int val; struct _Node* next; }Node,*LinkList; //不带头结点的单链表 void Init(LinkList* list) { (*list) = NULL; } void Creat(Link
假设以不带头节点的循环单链表表示队列，并且只设一个指针指向队尾节点，但不设头指针，请设计出对应的出队和入队算法
10-31
当使用不带头节点的循环单链表表示队列时，由于没有显式的头节点，我们可以利用链表的特性，即最后一个元素的下一个元素仍然是第一个元素，来模拟队列的先进先出（FIFO）行为。在这种情况下，我们只需要维护一个指向...
【2009真题】已知一个带有表头结点的单链表，假设该链表只给出了头指针list。在不改变链表的前提下，查找链表中倒数第k个位置上的结点。
2301_78338229的博客
07-18 574
问题的关键是设计一个尽可能高效的算法，通过链表的一次遍历，找到倒数第k个结点的位置。算法的基本设计思想是：定义两个指针变量p和q,初始时均指向头结点的下一个结点（链表的第一个结点）,P指针沿链表移动；当p指针移动到最后一个结点时，q指针所指示结点为倒数第k个结点。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点（k为正整数）。若查找成功，算法输出该结点的data域的值，并返回1;⑤若count等于k,则查找成功，输出该结点的data域的值，返回1;
c语言将一个已知头结点的单链表逆序_C语言实现单链表反转
weixin_35323550的博客
01-16 1300
一、理解指针看懂链表的结构并不是很难，但是一旦把它和指针混在一起，就很容易让人摸不着头脑。所以，要想写对链表代码，首先就要理解好指针。有些语言有“指针”的概念，比如 C 语言；有些语言没有指针，取而代之的是“引用”，比如 Java、Python。不管是“指针”还是“引用”，实际上，它们的意思都是一样的，都是存储所指对象的内存地址。将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过...
编写算法，将一个头指针为head且不带头节点的单链表改造为一个含头结点且头指针仍为head的单项循环链表
03-20
3. 修改新的头节点 `newHead` 的指针域使其指向原来的第一个有效节点（原链表的第一个节点）。 4. 返回新的头节点作为整个链表的新起点。 以下是具体的 Python 代码实现： ```python class Node: def __init__...
【数据结构】给定一个带头结点的单链表L，设head为头指针，结点的结构为（data，next），data为整型元素，next为指针。
weixin_51280571的博客
08-08 5094
题目：给定一个带头结点的单链表L，设head为头指针，结点的结构为（data，next），data为整型元素，next为指针。设计算法，将L逆置，要求算法的空间复杂度为O(1)。3.确定采用头插法，因为用该方法建立链表，得到链表中元素的顺序和输入的顺序相反，可以利用这一个特点，将单链表逆置；最好的情况就是链表长度只有1，无需逆置，最坏的情况使链表长度为n，就需要进循环n次。1.理解算法空间复杂度为O（1），即为没有申请额外的空间；当链表长度为1时，while循环里的语句执行1次；（1）给出算法的设计思想。.
数据结构 不带头结点的单链表 删除
m0_73448628的博客
04-08 1721
c语言数据结构实验题，不带头结点的单链表
不带头结点的单链表（增、删、查、改）
weixin_50603017的博客
01-09 2536
#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--第一个结点的数据元素的值 函数返回值： 返回堆区创建出来的第一个结点首地址 函数作用： 创建一个只有一个结点的链表 *.
没有头结点的单链表如何删除结点
Bruce Lee的专栏
09-09 4715
题目：假设有一个没有头结点的单链表。一个指针指向此单链表中间的一个节点（非第一个节点， 也非最后一个节点）。请将该节点从单链表中删除。 典型的“狸猫换太子”， 若要删除该节点，正常情况下，应该要知道该节点的前面节点的指针，但是由于单链表中没有头结点，所以无法追溯到该节点前面的那个节点，因此，这里采用了“移花接木”的方法。设该节点为B，下一个节点为C。那么，首先将B节点的内容替换为C节点的内容，然
删除不带头结点的单链表L中所有值为x的结点（递归实现）
qq_51950769的博客
06-10 1141
为什么这段代码在执行 ls = ls->next 会误以为有断链的感觉
C++不使用头结点创建单链表，并实现删除某个结点的功能
qq_38220144的博客
07-13 462
头部声明如下 #include <iostream> #include <malloc.h> using namespace std; typedef int ElemType; typedef struct LNode{ ElemType data;//存放数据元素值 struct LNode *next; }LinkNode; 以下是主函数： ...
C语言实现单链表（不带头节点）的删除插入完整代码
qq_54628272的博客
02-10 3259
注意：不带头节点的单链表删除插入操作第一个节点的时候都要特殊讨论 以下代码是用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, ..
单链表删除指定元素(不带头结点)
weixin_45653543的博客
08-16 1882
单链表删除指定元素
不带头节点的单链表操作 增删改查
weixin_45951224的博客
02-23 1442
单链表增删改查
从无头单链表中删除节点
一个平凡的技术热爱者
04-27 629
从无头单链表中删除节点的问题分析与算法实现。
基于java已知一个带头节点单链表，自定义一个算法insert实现在第i个节点前面插入元素X的操作
最新发布
06-20
<think>我们正在处理一个单链表（带头节点）的插入操作。目标是在第i个节点前插入一个元素X。根据引用[1]和引用[3]的内容，我们知道：-单链表通常有一个头节点（root），这样方便操作。-插入操作需要找到要插入位置的前一个节点。注意：题目要求在第i个节点前插入，也就是说，如果我们要插入到第i个位置（即成为链表的第i个节点），那么实际上是在第i-1个节点之后插入。但是，如果i=1，表示要在第一个节点前插入，也就是插入后成为新的第一个节点。由于我们有头节点，第一个节点实际上是头节点的下一个节点。因此，我们可以这样设计：1.首先，我们需要检查插入位置i是否合法（i应该大于0且小于等于链表长度+1？注意：我们是在第i个节点前插入，所以i的范围应该是[1,size+1]）。-当i=1时，表示在第一个节点前插入，即头节点之后插入。-当i=size+1时，表示在最后一个节点之后插入（也就是在末尾添加）。2.然后，我们从头节点开始遍历，找到第i-1个节点（即要插入位置的前一个节点）。注意：因为头节点是第0个节点（不存储数据），所以我们要找的是第i-1个节点。3.创建新节点，并将新节点的next指向第i-1个节点的下一个节点（即原来的第i个节点）。4.将第i-1个节点的next指向新节点。但是，这里有一个特殊情况：如果链表为空（只有头节点），那么当i=1时，插入是合法的（插入后链表有一个数据节点）；当i>1时，则不合法。另外，我们还需要注意链表长度的更新。根据上述分析，我们来实现insert方法：假设我们有一个单链表类，其中：-内部类Node，包含数据域data和指针域next。-头节点head（不存储数据，第一个数据节点是head.next）-可能还有size记录节点数（数据节点个数）方法签名：publicvoidinsert(inti,Ex)步骤：1.检查i的合法性：i必须大于等于1且小于等于size+1（因为可以在最后一个节点之后插入，即i=size+1）。2.从头节点开始，移动到第i-1个位置（即要插入位置的前驱节点）。我们用一个指针current，初始指向头节点（位置0），然后移动i-1次。3.创建新节点，其数据为x。4.将新节点的next指向current.next。5.将current.next指向新节点。6.更新size（如果维护了size）。注意：如果i=1，那么current就是头节点，插入在头节点后面，这是正确的。如果i=size+1，那么current会移动到最后一个节点，然后在最后一个节点后面插入，即新节点成为最后一个节点。代码实现如下：</think>### Java单链表（带头节点）在第i个节点前插入元素X的实现 以下是完整的Java代码实现，基于带头节点的单链表结构，实现了在指定位置插入元素的功能： ```java // 定义链表节点类 class Node<T> { T data; // 节点数据 Node<T> next; // 指向下一个节点的指针 public Node(T data) { this.data = data; this.next = null; } } // 定义带头节点的单链表类 class LinkedList<T> { private Node<T> head; // 头节点（不存储实际数据） private int size; // 链表长度 public LinkedList() { head = new Node<>(null); // 创建空头节点 size = 0; } /** * 在第i个节点前插入元素X * @param index 插入位置（从1开始计数） * @param data 要插入的数据 * @throws IndexOutOfBoundsException 如果位置非法 */ public void insert(int index, T data) { // 验证位置有效性（1 ≤ i ≤ size+1） if (index < 1 || index > size + 1) { throw new IndexOutOfBoundsException("插入位置无效: " + index); } Node<T> newNode = new Node<>(data); Node<T> current = head; // 从头节点开始遍历 // 移动到插入位置的前驱节点（第i-1个节点） for (int pos = 0; pos < index - 1; pos++) { current = current.next; } // 执行插入操作 newNode.next = current.next; // 新节点指向原位置节点 current.next = newNode; // 前驱节点指向新节点 size++; // 更新链表长度 } // 其他辅助方法（可选） public void printList() { Node<T> current = head.next; while (current != null) { System.out.print(current.data + " -> "); current = current.next; } System.out.println("null"); } } // 使用示例 public class Main { public static void main(String[] args) { LinkedList<String> list = new LinkedList<>(); // 在位置1插入（链表为空时相当于首插） list.insert(1, "A"); // 在位置1插入（成为新首节点） list.insert(1, "B"); // 在位置3插入（相当于尾插） list.insert(3, "C"); list.printList(); // 输出: B -> A -> C -> null } } ``` ### 关键实现说明： 1. **头节点作用**：头节点（`head`）不存储实际数据，其`next`指向第一个数据节点，统一了首节点和其他节点的插入操作逻辑[^1][^3] 2. **位置参数**： - `index=1` 表示在第一个数据节点前插入（成为新首节点） - `index=size+1` 表示在链表末尾插入 3. **插入流程**： - 遍历到位置`i-1`的节点（前驱节点） - 新节点`next`指向原`i`位置节点 - 前驱节点`next`指向新节点 4. **边界处理**： - 首节点插入：`index=1`，前驱节点即头节点 - 尾节点插入：`index=size+1`，前驱节点即尾节点 - 空链表插入：自动成为首节点 ### 时间复杂度： - **最优**：$O(1)$（插入到链表头部） - **最差**：$O(n)$（插入到链表尾部） - **平均**：$O(n)$ 此实现严格遵循了单链表在指定位置前插入元素的规范要求[^3]，通过头节点简化了首节点操作的特殊处理，确保了操作一致性。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值