如何删除链表的中间节点和a/b处的节点？

最新推荐文章于 2024-09-23 09:50:33 发布
最新推荐文章于 2024-09-23 09:50:33 发布
阅读量1k 收藏 25
点赞数 12
文章标签： 链表 windows 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqrrjj2011/article/details/142449415
版权

文章目录


在链表中删除中间节点或者特定位置（如 a/b 处）的节点涉及到一些基本的链表操作。下面我将分别解释这两种情况下的处理方法。

删除中间节点

假设“中间节点”是指链表从头到尾节点数量的中间位置。对于长度为偶数或奇数的链表，中间节点的位置可能略有不同。以下是删除中间节点的基本步骤：

  1. 确定中间节点的位置：

    • 可以使用快慢指针技术来找到中间节点。快指针每次移动两步，慢指针每次移动一步，当快指针到达链表尾部时，慢指针就在中间位置。

  2. 删除中间节点：

    • 当找到了中间节点后，需要调整指针以跳过该节点。如果是单链表，需要让前一个节点指向当前中间节点的下一个节点。
    • 如果是双链表，则只需要调整当前节点的前后指针即可。

删除 a/b 处的节点

删除 a/b 处的节点意味着要删除从头部开始的第 a/b * 链表长度 的节点。这里的 a 和 b 是整数，并且 a < b。具体操作如下：

  1. 计算 a/b 处的位置：

    • 首先遍历整个链表来获取链表的长度 N。
    • 计算目标节点的位置 pos = ceil((a / b) * N)，这里 ceil 表示向上取整。

  2. 删除指定位置的节点：

    • 再次遍历链表直到 pos-1 位置，这里的 pos 是计算得到的位置。
    • 调整 pos-1 位置节点的 next 指针，使其指向 pos+1 位置的节点，从而跳过 pos 位置的节点。

注意：在实际编程中，你需要考虑边界条件，比如链表为空的情况，或者 a/b 导致的位置超出链表范围等。
以上描述的是算法上的逻辑，具体的实现会依赖于使用的编程语言和链表的具体实现方式

示例

接下来我会提供一些伪代码示例来帮助理解如何实现上述两种情况。请注意，这些示例将基于单向链表进行说明。

定义链表节点结构

首先定义一个简单的链表节点结构：

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next
删除中间节点

假设我们已经有一个链表 head，我们将使用快慢指针的方法来找到中间节点并删除它：

def delete_middle_node(head):
    if not head or not head.next:
        return None
    
    slow = head
    fast = head
    prev = None
    
    # 使用快慢指针找到中间节点
    while fast and fast.next:
        fast = fast.next.next
        prev = slow
        slow = slow.next
    
    # 删除中间节点
    if prev:
        prev.next = slow.next
    else:  # 如果中间节点是头节点
        head = slow.next
    
    return head
删除 a/b 处的节点

为了删除 a/b 处的节点，我们需要首先计算出确切的位置，然后找到该位置的前一个节点，并进行删除操作：

def delete_node_at_position(head, a, b):
    if not head or not head.next:
        return None
    
    length = 0
    temp = head
    
    # 计算链表的长度
    while temp:
        length += 1
        temp = temp.next
    
    # 计算目标位置
    target_pos = int((a / b) * length)
    
    # 特殊情况处理
    if target_pos == 0:
        return head.next
    
    current = head
    count = 0
    
    # 找到目标节点的前一个节点
    while current and count < target_pos - 1:
        current = current.next
        count += 1
    
    if current and current.next:
        current.next = current.next.next
    
    return head

注意事项

  • 这些函数返回了修改后的链表头节点。
  • 在实际应用中，你可能需要根据具体需求调整边界条件处理。
  • delete_node_at_position 函数假设 a 和 b 是有效的输入，即 a 总是小于 b，并且 a / b 不会超过链表长度的比例。

Python 实现案例

下面是具体的 Python 实现案例，包括创建链表、删除中间节点以及删除 a/b 处节点的完整代码示例。

创建链表

首先，我们需要定义链表节点类，并编写一个函数来创建一个链表：

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

def create_linked_list(values):
    dummy_head = ListNode()
    current = dummy_head
    for value in values:
        current.next = ListNode(value)
        current = current.next
    return dummy_head.next

删除中间节点

接下来，我们实现删除中间节点的功能：

def delete_middle_node(head):
    if not head or not head.next:
        return None
    
    slow = head
    fast = head
    prev = None
    
    # 使用快慢指针找到中间节点
    while fast and fast.next:
        fast = fast.next.next
        prev = slow
        slow = slow.next
    
    # 删除中间节点
    if prev:
        prev.next = slow.next
    else:  # 如果中间节点是头节点
        head = slow.next
    
    return head

删除 a/b 处的节点

然后，实现删除 a/b 处节点的功能：

def delete_node_at_position(head, a, b):
    if not head or not head.next:
        return None
    
    length = 0
    temp = head
    
    # 计算链表的长度
    while temp:
        length += 1
        temp = temp.next
    
    # 计算目标位置
    target_pos = int((a / b) * length)
    
    # 特殊情况处理
    if target_pos == 0:
        return head.next
    
    current = head
    count = 0
    
    # 找到目标节点的前一个节点
    while current and count < target_pos - 1:
        current = current.next
        count += 1
    
    if current and current.next:
        current.next = current.next.next
    
    return head

测试代码

最后，我们编写一个测试函数来验证这些功能：

def print_linked_list(head):
    current = head
    while current:
        print(current.value, end=" -> ")
        current = current.next
    print("None")

# 创建一个示例链表
values = [1, 2, 3, 4, 5]
linked_list = create_linked_list(values)

print("Original Linked List:")
print_linked_list(linked_list)

# 删除中间节点
linked_list = delete_middle_node(linked_list)
print("Linked List after deleting middle node:")
print_linked_list(linked_list)

# 删除 a/b 处的节点 (例如 a=1, b=2)
linked_list = delete_node_at_position(linked_list, 1, 2)
print("Linked List after deleting node at position 1/2:")
print_linked_list(linked_list)

这段代码将会创建一个包含 [1, 2, 3, 4, 5] 的链表，并演示如何删除中间节点以及删除 a/b 处的节点。你可以根据自己的需要调整 values 列表以及 a 和 b 的值来进行测试。

让我们继续通过具体的例子来测试删除中间节点和 a/b 处节点的功能。

示例代码完整版

以下是完整的 Python 代码示例，包括创建链表、删除中间节点、删除 a/b 处节点以及测试用例：

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next

def create_linked_list(values):
    dummy_head = ListNode()
    current = dummy_head
    for value in values:
        current.next = ListNode(value)
        current = current.next
    return dummy_head.next

def delete_middle_node(head):
    if not head or not head.next:
        return None
    
    slow = head
    fast = head
    prev = None
    
    # 使用快慢指针找到中间节点
    while fast and fast.next:
        fast = fast.next.next
        prev = slow
        slow = slow.next
    
    # 删除中间节点
    if prev:
        prev.next = slow.next
    else:  # 如果中间节点是头节点
        head = slow.next
    
    return head

def delete_node_at_position(head, a, b):
    if not head or not head.next:
        return None
    
    length = 0
    temp = head
    
    # 计算链表的长度
    while temp:
        length += 1
        temp = temp.next
    
    # 计算目标位置
    target_pos = int((a / b) * length)
    
    # 特殊情况处理
    if target_pos == 0:
        return head.next
    
    current = head
    count = 0
    
    # 找到目标节点的前一个节点
    while current and count < target_pos - 1:
        current = current.next
        count += 1
    
    if current and current.next:
        current.next = current.next.next
    
    return head

def print_linked_list(head):
    current = head
    while current:
        print(current.value, end=" -> ")
        current = current.next
    print("None")

# 创建一个示例链表
values = [1, 2, 3, 4, 5]
linked_list = create_linked_list(values)

print("Original Linked List:")
print_linked_list(linked_list)

# 删除中间节点
linked_list = delete_middle_node(linked_list)
print("Linked List after deleting middle node:")
print_linked_list(linked_list)

# 删除 a/b 处的节点 (例如 a=1, b=2)
linked_list = delete_node_at_position(linked_list, 1, 2)
print("Linked List after deleting node at position 1/2:")
print_linked_list(linked_list)

测试输出

这段代码的预期输出如下：

Original Linked List:
1 -> 2 -> 3 -> 4 -> 5 -> None
Linked List after deleting middle node:
1 -> 2 -> 4 -> 5 -> None
Linked List after deleting node at position 1/2:
1 -> 4 -> 5 -> None

在这个例子中：

  1. 原始链表为 [1, 2, 3, 4, 5]。
  2. 删除中间节点（3），链表变为 [1, 2, 4, 5]。
  3. 删除 a/b 处的节点（即 a=1, b=2 时，目标位置为 (1/2) * 4 = 2），删除第二个节点（2），链表变为 [1, 4, 5]。

你可以根据需要调整 values 列表中的值以及 a 和 b 的值来测试不同的情况。

😍😍 海量H5小游戏、微信小游戏、Web casualgame源码😍😍
😍😍试玩地址： https://www.bojiogame.sg😍😍
😍看上哪一款，需要源码的csdn私信我😍

————————————————

​最后我们放松一下眼睛
在这里插入图片描述

极致人生-010
关注
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
m0_66793065的博客
03-20 4046
## 题目描述 给定一个单链表 L，请编写程序输出 L 中间结点保存的数据。 如果有两个中间结点，则输出第二个中间结点保存的数据。例如： 给定 L 为 1→7→5，则输出应该为7； 给定 L 为 1→2→3→4，则输出应该为3； 输入描述 每个输入包含1个测试用例。 每个测试用例： 第一行给出链表首结点的地址、结点总个数正整数 N （≤ 10^5）。结点的地址是5位非负整数，NULL地址用-1表示。 接下来有N行，每行格式位： Address Data Next 其中Address是结点地址，
链表中的中间节点
a1085653724的博客
05-06 1394
1.给定一个头结点为head的非空单链表，返回链表的中间结点。 如果有两个中间结点，则返回第二个中间结点。 示例 1： 输入：[1,2,3,4,5] 输出：此列表中的结点 3 (序列化形式：[3,4,5]) 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。 注意，我们返回了一个 ListNode 类型的对象 ans，这样： ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next..
链表问题---删除链表的中间节点和a/b处的节点
冰殇的博客
10-12 701
【题目】　　给定链表的头节点head，实现删除链表的中间节点的函数。 　　例如： 　　1，不删除任何节点 　　1 -> 2，删除节点1 　　1 -> 2 -> 3，删除节点2 　　1 -> 2 -> 3 -> 4，删除节点2 　　1 -> 2 -> 3 -> 4 -> 5，删除节点3　　进阶问题： 　　给定链表的头节点head，整数a和整数b，实现删除位于a/b处节点的函数。 　　例
【数据结构和算法】删除链表的中间节点
kologin的博客
01-15 1812
这是力扣的1657题，难度为中等，解题方案有很多种，本文讲解我认为最奇妙的一种。慢慢开始链表的模块了，这道题是一道非常好的队列的例题，很有代表性。给你一个链表的头节点head。删除链表的中间节点，并返回修改后的链表的头节点head。 长度为n链表的中间节点是从头数起第⌊n / 2⌋个节点（下标从0开始），其中⌊x⌋表示小于或等于x的最大整数。 对于n=1、2、3、4和5的情况，中间节点的下标分别是0、1、1、2和2。
C++丨删除链表中间节点的方法详解
Hsuesh的博客
01-14 890
这篇文章主要介绍了C++删除链表中间节点的方法,结合实例形式分析了链表删除中间节点的具体思路与实现技巧,希望在学习上有帮助到大家。
单向链表中间节点 华为OD真题 100
choukai0932的博客
12-08 2095
华为od机考
算法：删除链表节点
一枚不断学习的小码农一枚~
03-17 6663
237. 删除链表中的节点 请编写一个函数，用于 删除单链表中某个特定节点 。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 示例 1： 输入：head = [4,5,1,9], node = 5 输出：[4,1,9] 解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9 示例 2： 输入：head = [4,5,1,9], node = 1 输出：[4,5,9]
单向链表中间节点
bdmh的专栏
04-30 1012
求单向链表中间的节点值，如果奇数个节点取中间，偶数个取偏右边的那个值。
codingInterview 链表—删除链表的中间节点
SUNBO、的博客
04-30 521
文章目录删除链表的中间节点【题目】【解答】 删除链表的中间节点 【题目】 给定链表的头节点head，实现删除链表的中间节点的函数。 例如： 不删除任何节点; 1->2,删除节点1； 1->2->3，删除节点2； 1->2->3->4，删除节点2； 1->2->3->4->5，删除节点3； 进阶： 给定链表的头节点head、整数a和b，实现...
C++删除链表中间节点的方法
08-30
在C++中，我们可以定义一个结构体`Node`来表示链表节点，其中包含一个整型数据`data`和一个指向下一个节点的指针`next`： ```cpp typedef struct Node{ int data; struct Node* next; } node, *pLinkedList; ``` ...
给定链表中间节点指针，删除中间节点的方法
09-15
这个方法的关键在于，它利用了链表节点的数据交换特性，而不是传统的通过前一个节点来修改`next`指针的方式。这种方法对于单链表中没有前向引用的情况非常有用。然而，需要注意的是，此方法不适用于删除链表的最后一...
第二章 链表问题（删除链表的中间节点和a/b处的节点）
qq_34616001的博客
07-11 164
【题目】 1、删除链表的中间节点 给定链表的头结点head，实现删除链表的中间节点的函数： 例如： 不删除任何节点； 1-->2，删除节点1； 1-->2-->3，删除节点2 1-->2-->3-->4，删除节点2； 1-->2-->3-->4-->5，删除节点3； Node<Integer> delMid(Node<Integer> head) { // 找到中间节点 if
Java Stream流编程入门
2301_77207909的博客
09-21 510
Java StreamAPI的使用与常用方法
【java17】java17新特性之Stream.toList()
morris
09-23 394
UnmodifiableList是Java中的一个类，用于创建不可修改的列表。它实际上是通过Collections.unmodifiableList()方法创建的。一旦列表被创建为不可修改的，就无法对其进行添加、删除或修改元素的操作。这种列表对于保护数据不被意外修改或者共享数据而不希望被修改很有用。当你想要确保某个列表在传递给其他代码时不会被修改时，可以使用UnmodifiableList来包装你的列表。
字体字体字体字体字体
一起记录GIS学习
09-23 612
<string>宋体</string>
ControllerAdvice定义统一异常处理
最新发布
小短腿
09-23 327
使用@RestControllerAdvice统一处理异常信息。
小小扑克牌算法
2302_81707171的博客
09-20 439
List < List< Colletion ? extends E > > 的运用
C++模拟实现list：list、list类的初始化和尾插、list的迭代器的基本实现、list的完整实现、测试、整个list类等的介绍
Farewell_me的博客
09-20 702
C++模拟实现list：list、list类的初始化和尾插、list的迭代器的基本实现、list的完整实现、测试、整个list类等的介绍C++模拟实现list：list、list类的初始化和尾插、list的迭代器的基本实现、list的完整实现、测试、整个list类等的介绍。
链表中如何找到链表中间节点
05-11
要找到链表中间节点，可以采用快慢指针的方法。具体步骤如下： 1. 定义两个指针，一个快指针和一个慢指针，初始时两个指针都指向链表的头节点。 2. 快指针每次移动两个节点，慢指针每次移动一个节点，直到快指针到达链表末尾，此时慢指针所指的节点就是链表的中间节点。 下面是代码示例： ``` ListNode* findMiddleNode(ListNode* head) { ListNode* fast = head; ListNode* slow = head; while (fast != nullptr && fast->next != nullptr) { fast = fast->next->next; slow = slow->next; } return slow; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极致人生-010

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值