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

问题描述:

给定链表的头结点head,实现删除链表的中间节点的函数:

例如:

不删除任何节点;

1-->2,删除节点1;

1-->2-->3,删除节点2

1-->2-->3-->4,删除节点2;

1-->2-->3-->4-->5,删除节点3;

分析及解题思路:

  对于删除链表中的中间节点而言,当节点数增加2时,要删除的中间节点向后移一位。比如,首先链表中没有节点或节点为1个时,直接返回头结点;当节点数为2个时,直接返回head.next;对于三个节点以上的情况,有如下解决过程:

  对于删除链表中的某个节点,要知道该节点的前一个节点的位置,只需将前一个节点的位置的next区域指向要删除节点的下一个位置即可。

  当链表节点的个数为3个时,则删除第二个节点,当节点数增加2时,此时要删除的节点就向后移一位。比如,当节点数为4个时,也是删除第二个节点;当节点数为5时,此时要删除第三个节点。所以首先pre指向头节点(pre每次指向要删除节点的前一个节点),cur指向pre节点的下一个节点的下个节点,然后判断当cur的下一个节点存在以及下下个节点存在时,说明在最初节点数为3个的基础上链表节点的个数增加2个,则pre指向后一个节点,cur指向下一个节点的下一个节点;直到cur的下一个节点或者下下个节点不存在时,循环结束,此时pre指向的位置正好是要删除链表中间节点的前一个节点的位置。这时删除节点即可。

代码实现:

 1 class Node(object):
 2     def __init__(self, data):
 3         self.data = data
 4         self.next = None
 5
 6 def createSingleLink(num):
 7     head = Node(1)
 8     cur = head
 9     for i in range(2, num+1):
10         cur.next = Node(i)
11         cur = cur.next
12     return head
13
14 def printSingleLink(head):
15     cur = head
16     while cur:
17         print(cur.data, end=‘‘)
18         if cur.next:
19             print(‘-->‘, end=‘‘)
20         cur = cur.next
21
22 def removeMidNode(head):
23     if head is None or head.next is None:
24         return head
25     if head.next.next is None:
26         return head.next
27     pre = head
28     cur = head.next.next
29     while cur.next and cur.next.next:
30         pre = pre.next
31         cur = cur.next.next
32     pre.next = pre.next.next
33     return head
34
35 if __name__ == ‘__main__‘:
36     singleLinkHead = createSingleLink(9)
37     printSingleLink(singleLinkHead)
38     newSingleLinkHead = removeMidNode(singleLinkHead)
39     print()
40     printSingleLink(newSingleLinkHead)

进阶:

  给定链表的头结点head、整数a和b,实现删除位于a/b处节点的函数。

例如:

链表:1-->2-->3-->4-->5,假设a/b的值为r。

  • 如果r等于0,不删除任何节点;
  • 如果r在区间(0, 1/5]上,删除节点1;
  • 如果r在区间(1/5, 2/5]上,删除节点2;
  • 如果r在区间(2/5 3/5]上,删除节点3;
  • 如果r在区间(3/5, 4/5]上,删除节点4;
  • 如果r在区间(4/5, 1]上,删除节点5;
  • 如果r大于1,不删除任何节点。

分析及解题思路:

  首先,当给出a和b的值后,要确定删除的是哪个节点,通过下面的式子的结果r来确定要删除的哪个节点,其中n为链表节点的个数:

r = (a * n) / b

最终的r向上取整,例如:

N = 5,a = 3,b = 5

则r = 3,即删除第三个节点;

N = 5,a = 3,b = 4

则r = 3.75,向上取整后删除的节点为第4个节点;

N = 5,a = 2,b = 6

则r = 1.6667,向上取整后删除的节点为第2个节点;

代码实现:

 1 import math
 2 class Node(object):
 3     def __init__(self, data):
 4         self.data = data
 5         self.next = None
 6
 7 def createSingleLink(num):
 8     head = Node(1)
 9     cur = head
10     for i in range(2, num+1):
11         cur.next = Node(i)
12         cur = cur.next
13     return head
14
15 def printSingleLink(head):
16     cur = head
17     while cur:
18         print(cur.data, end=‘‘)
19         if cur.next:
20             print(‘-->‘, end=‘‘)
21         cur = cur.next
22
23 def removeByRatio(head, a, b):
24     if a < 1 or a > b:
25         return head
26     cur = head
27     n = 0
28     while cur:
29         n += 1
30         cur = cur.next
31     r = math.ceil((a * n) / b)
32     if r == 1:
33         head = head.next
34     if r > 1:
35         pre = head
36         while r > 2:
37             r -= 1
38             pre = pre.next
39         pre.next = pre.next.next
40     return head
41
42 if __name__ == ‘__main__‘:
43     singleLinkHead = createSingleLink(5)
44     printSingleLink(singleLinkHead)
45     newSingleLinkHead = removeByRatio(singleLinkHead, 5, 5)
46     print()
47     printSingleLink(newSingleLinkHead)

原文地址:https://www.cnblogs.com/dabric/p/11723110.html

时间: 2024-12-09 07:13:43

删除链表的中间节点和a/b处的节点的相关文章

链表问题----删除链表的中间节点和a/b处的节点

删除链表的中间节点和a/b处的节点 对于给定一个链表的头节点head,实现删除链表的中间节点的函数. 例如 不删除任何节点: 1->2,删除节点1 1->2->3,删除节点2 1->2->3->4,删除节点2 1->2->3->4->5,删除节点3 如果将本问题复杂一下,给定链表的头节点head.整数a和整数b,实现删除位于a/b处节点的函数. 例如 链表:1->2->3->4->5,假设 a/b 的值为r 如果 r 等于

算法总结之 删除链表的中间节点和a/b处的节点(链表中间节点的重要思想)

给定链表的表头节点head,实现删除链表的中间节点的函数 推展: 给定链表的头节点,整数a 和 整数 b,实现删除a/b处节点的函数 先来分析原问题, 长度1  直接返回 长度2 将头节点删除 长度3 删除第二个  长度4 删除第二个  长度5 删除第三个......长度每增加2 删除的节点就向后移动一个节点 如果要删除一个节点,则需要找到待删除节点的前一个节点 package TT; public class Test87 { public class Node{ public int val

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

[题目]: 给定链表的头节点 head,实现删除链表的中间节点的函数. 例如: 步删除任何节点: 1->2,删除节点1: 1->2->3,删除节点2: 1->2->3->4,删除节点2: 1->2->3->4-5,删除节点3: [进阶]: 给定链表的头节点 head.整数 a 和 b,实现删除位于 a/b 处节点的函数. 例如: 链表:1->2->3->4->5,假设 a/b 的值为 r. 如果 r = 0,不删除任何节点: 如

2.3 删除链表的中间节点和a/b处的节点

题目:给定链表的头结点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处节点的函数 例如: 链表: 1 --> 2 --> 3 --> 4 -->

剑指Offer之在O(1)时间删除链表节点

题目描述 给定单向链表的头指针和一个节点指针,定义一个函数在O(1)时间删除该节点. 解题思路 在单向链表中删除一个节点,最常规的做法无疑是从链表的头结点开始,顺序的遍历查找要删除的节点,并在链表中删除该节点.这种思路由于需要顺序查找,时间复杂度自然就是$O(n)$了. 之所以需要从头开始查找,是因为我们需要得到将删除的节点的前面一个节点.在单向链表中,节点中没有指向前一个节点的指针,所以只好从链表的头结点开始顺序查找.那是不是一定需要得到被删除的节点的前一个节点呢?答案是否定的.我们可以很方便

删除链表中倒数第n个节点

1.给定一个链表,删除链表中倒数第n个节点,返回链表的头节点. 给出链表1->2->3->4->5->null和 n = 2. 删除倒数第二个节点之后,这个链表将变成1->2->3->5->null. 注意 链表中的节点个数大于等于n 挑战 O(n)时间复杂度 解题思路:刚开始看到倒数第n个节点,不禁感慨如果是数组就可以直接倒着来了.不过针对链表,一定要想起来最常用的方法---快慢指针.设一个fast和slow指针:快指针先走n步,然后快慢指针一起走,

【链表】在O(1)的时间删除链表的节点

1 /** 2 * 在O(1)的时间删除链表的节点 3 * 4 * @author 5 * 6 */ 7 public class Solution { 8 9 public static void deleteNode(Node head, Node deletedNode) { 10 if (null == head || null == deletedNode) { 11 return; 12 } 13 14 if (deletedNode.next != null) { // 删除的不是

[LeetCode]79. Delete Node in a Linked List删除链表节点

Write a function to delete a node (except the tail) in a singly linked list, given only access to that node. Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list should become 1 -> 2 ->

lintcode 容易题:Remove Nth Node From End of Lis 删除链表中倒数第n个节点

题目: 删除链表中倒数第n个节点 给定一个链表,删除链表中倒数第n个节点,返回链表的头节点.  样例 给出链表1->2->3->4->5->null和 n = 2. 删除倒数第二个节点之后,这个链表将变成1->2->3->5->null. 注意 链表中的节点个数大于等于n 解题: 要删除倒数第n个节点,我们要找到其前面一个节点,也就是倒数第n+1的节点,找到这个节点就可以进行删除.和上题的思想很类似, 定义两个指针,p和cur,cur指针向前走,走了n