精华内容
下载资源
问答
  • python删除链表重复元素
    2020-07-18 19:59:36

    删除链表重复元素

    给定链表
    1 -> 1 -> 3 -> 4

    删除1
    新链表:
    1->3->4

    思路, 判断当前节点和next节点的val相等不相等, 如果相等, 跳过下一个节点
    curr.next = curr.next.next

    class Node:
      def __init__(self, x):
        self.val = x
        self.next = None
    
    def deletdup(phead):
      curr = phead
      while curr != None and curr.next != None:
        if curr.val == curr.next.val:
          curr.next = curr.next.next
        else:
          curr = curr.next
      return phead
    

    测试:

    
    node1 = Node(1)
    node2 = Node(1)
    node3 = Node(3)
    node4 = Node(4)
    
    node1.next = node2
    node2.next = node3
    node3.next = node4
    
    new = deletdup(node1)
    
    new.next.val
    

    3

    更多相关内容
  • 题目描述:给定一个没有排序的链表,去掉重复项,并保留原顺序 如: 1->3->1->5->5->7,去掉重复项后变为:1->3->5->7方法:顺序删除递归删除1.顺序删除由于这种方法采用双重循环对链表进行...

    题目描述:

    给定一个没有排序的链表,去掉重复项,并保留原顺序 如: 1->3->1->5->5->7,去掉重复项后变为:1->3->5->7

    方法:

    顺序删除

    递归删除

    1.顺序删除

    由于这种方法采用双重循环对链表进行遍历,因此,时间复杂度为o(n**2)

    在遍历链表的过程中,使用了常数个额外的指针变量来保存当前遍历的结点,前驱结点和被删除的结点,所以空间复杂度为o(1)

    #!/usr/bin/env python3

    # -*- coding: utf-8 -*-

    # @time : 2020/1/15 20:55

    # @author : buu

    # @software: pycharm

    # @blog :https://blog.csdn.net/weixin_44321080

    class lnode:

    def __init__(self, x):

    self.data = x

    self.next = none

    def removedup(head):

    """

    对带头结点的无序单链表删除重复的结点

    顺序删除:通过双重循环直接在链表上进行删除操作

    即,外层循环用一个指针从第一个结点开始遍历整个链表,内层循环从外层指针指向的下一个结点开始,

    遍历其余结点,将与外层循环遍历到的的指针所指的结点的数据域相同的结点删除

    :param head: 头指针

    :return:

    """

    if head is none or head.next is none:

    return

    outercur = head.next

    innercur = none

    innerpre = none

    while outercur is not none:

    innercur = outercur.next

    innerpre = outercur

    while innercur is not none:

    if outercur.data == innercur.data:

    innerpre.next = innercur.next

    innercur = innercur.next

    else:

    innerpre = innercur

    innercur = innercur.next

    outercur = outercur.next

    if __name__ == '__main__':

    i = 1

    head = lnode(6)

    tmp = none

    cur = head

    while i < 7:

    if i % 2 == 0:

    tmp = lnode(i + 1)

    elif i % 3 == 0:

    tmp = lnode(i - 2)

    else:

    tmp = lnode(i)

    cur.next = tmp

    cur = tmp

    i += 1

    print("before removedup:")

    cur = head.next

    while cur is not none:

    print(cur.data, end=' ')

    cur = cur.next

    removedup(head)

    print("\nafter removedup:")

    cur = head.next

    while cur is not none:

    print(cur.data, end=' ')

    cur = cur.next

    结果:

    d699207b836c9b61ab766422118f07f6.png

    2.递归

    此方法与方法一类似,从本质上而言,由于这种方法需要对链表进行双重遍历,所以时间复杂度为o(n**2)

    由于递归法会增加许多额外的函数调用,所以从理论上讲,该方法效率比方法一低

    #!/usr/bin/env python3

    # -*- coding: utf-8 -*-

    # @time : 2020/1/15 21:30

    # @author : buu

    # @software: pycharm

    # @blog :https://blog.csdn.net/weixin_44321080

    class lnode:

    def __init__(self, x):

    self.data = x

    self.next = none

    def removeduprecursion(head):

    """

    递归法:将问题逐步分解为小问题,即,对于结点cur,首先递归地删除以cur.next为首

    的子链表中重复的结点;接着删除以cur为首的链表中的重复结点,

    :param head:

    :return:

    """

    if head.next is none:

    return head

    pointer = none

    cur = head

    head.next = removeduprecursion(head.next)

    pointer = head.next

    while pointer is not none:

    if head.data == pointer.data:

    cur.next = pointer.next

    pointer = cur.next

    else:

    pointer = pointer.next

    cur = cur.next

    return head

    def removedup(head):

    """

    对带头结点的单链表删除重复结点

    :param head: 链表头结点

    :return:

    """

    if head is none:

    return

    head.next = removeduprecursion(head.next)

    if __name__ == '__main__':

    i = 1

    head = lnode(6)

    tmp = none

    cur = head

    while i < 7:

    if i % 2 == 0:

    tmp = lnode(i + 1)

    elif i % 3 == 0:

    tmp = lnode(i - 2)

    else:

    tmp = lnode(i)

    cur.next = tmp

    cur = tmp

    i += 1

    print("before recursive removedup:")

    cur = head.next

    while cur is not none:

    print(cur.data, end=' ')

    cur = cur.next

    removedup(head)

    print("\nafter recurseve removedup:")

    cur = head.next

    while cur is not none:

    print(cur.data, end=' ')

    cur = cur.next

    结果:

    2c01850f7a4edb5eead009aadda8aaa6.png

    引申:从有序链表中删除重复项

    上述介绍的方法也适用于链表有序的情况,但是由于上述方法没有充分利用到链表有序这个条件,因此,算法的性能肯定不是最优的。本题中,由于链表具有有序性,因此不需要对链表进行两次遍历。所以有如下思路:

    用cur指向链表的第一个结点,此时需要分为以下两种情况讨论:

    如果cur.data == cur.next.data,则删除cur.next结点;

    如果cur.data != cur.next.data,则cur=cur.next,继续遍历其余结点;

    总结

    以上所述是小编给大家介绍的python无序链表删除重复项的方法,希望对大家有所帮助

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • 删除给出链表中的重复元素链表中元素从小到大有序),使链表中的所有元素都只出现一次 例如: 给出的链表为1→1→21\to1\to21→1→2,返回1→21 \to 21→2. 给出的链表为1→1→2→3→31\to1\to 2 \to 3 \to 31→1→...

    一、问题描述

    删除给出链表中的重复元素(链表中元素从小到大有序),使链表中的所有元素都只出现一次
    例如:
    给出的链表为1→1→21\to1\to21→1→2,返回1→21 \to 21→2.
    给出的链表为1→1→2→3→31\to1\to 2 \to 3 \to 31→1→2→3→3,返回1→2→31\to 2 \to 31→2→3.

    数据范围:链表长度满足 0≤n≤1000 \le n \le 1000≤n≤100,链表中任意节点的值满足 ∣val∣≤100|val| \le 100∣val∣≤100
    进阶:空间复杂度 O(1)O(1)O(1),时间复杂度 O(n)O(n)O(n)

    示例:

    • 输入:{1,1,2}

    • 返回值:{1,2}

    二、解决思路

    分两种情况:

    • 当链表为空时,直接返回整个链表;
    • 当链表不为空时,使用cur指向头节点:
      若cur.next为空时,返回链表;若不为空时,判断cur的值是否与cur.next相同,如果相同,则令cur.next=cur.next.next,若不相同,cur=cur.next,指针后移。

    在这里插入图片描述

    三、python实现

    # class ListNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution:
        def deleteDuplicates(self , head: ListNode) -> ListNode:
            if not head:
                return head
            cur=head
            while cur.next:
                if cur.val==cur.next.val:
                    cur.next=cur.next.next
                else:
                    cur=cur.next
            return head
    					
    	
    
    展开全文
  • 给定一个已排序的链表的头 head , 删除所有重复元素,使每个元素只出现一次 。返回 已排序的链表 。 例: 输入:head = [1,1,2] 输出:[1,2] 解析: 创建一个指针,从头开始遍历,当后面的节点的值等于...

    给定一个已排序的链表的头 head删除所有重复的元素,使每个元素只出现一次 。返回 已排序的链表

    例:

    输入:head = [1,1,2]
    输出:[1,2]

    解析:

    创建一个指针,从头开始遍历,当后面的节点的值等于当前指针指向的节点的值时,让当前指针所指的节点的next指向下下个节点,也就是直接跳过下一个节点,不同的话,指针后移一个即可。

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, val=0, next=None):
    #         self.val = val
    #         self.next = next
    class Solution(object):
        def deleteDuplicates(self, head):
            """
            :type head: ListNode
            :rtype: ListNode
            """
            if head == None:  # 空判断
                return None
            
            flag = head  # 创建指针
            while flag.next != None:  # 循环条件
                if flag.val == flag.next.val:
                    flag.next = flag.next.next  # 跳过
                else:
                    flag = flag.next  # 指针后移
            return head

    展开全文
  • 删除链表中的重复元素 存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除所有重复的元素,使每个元素 只出现一次 。 返回同样按升序排列的结果链表。 输入:head = [1,1,2] 输出:[1,2] 输入:...
  • 【力扣python】83. 删除排序链表中的重复元素
  • 题目描述:给定一个排序链表删除所有重复元素每个元素只留下一个。您在真实的面试中是否遇到过这个题?Yes样例给出1->1->2->null,返回1->2->null给出1->1->2->3->3->null,返回1...
  • 题目链接难度: 中等 类型:链表给定一个排序链表删除所有含有重复数字的节点,只保留原始链表中 没有重复出现 的数字。示例1输入: 1->2->3->3->4->4->5输出: 1->2->5示例2输入: 1->1-...
  • leetCode第83题,删除排序链表中的重复元素 示例1: 输入:head = [1,1,2] 输出:[1,2] 示例2: 输入:head = [1,1,2,3,3] 输出:[1,2,3] 提示: 链表中节点数目在范围 [0, 300] 内 -100 <= Node.val <=...
  • 给定一个排序链表删除所有重复元素,使得每个元素只出现一次。 示例 1: 输入: 1->1->2 输出: 1->2 新学习新的开始,又开始写博客希望大家能一起学习,之前没写,因为课程太多了太多的考试,今年希望...
  • 删除排序链表中的重复元素 题目 给定一个排序链表删除所有重复的元素,使得每个元素只出现一次。 链接:https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/ 思路 由于是排序链表,所以只需...
  • 题目是不保留重复元素 def deleteDuplicates(self, head: ListNode) -> ListNode: dummy = ListNode(0) slow = dummy fast = head while fast != None: # 是否快进的标志 flag = False while fast.next !...
  • 题目链接难度:简单 类型: 链表给定一个排序链表删除所有重复元素,使得每个元素只出现一次。示例1输入: 1->1->2输出: 1->2示例2输入: 1->1->2->3->3输出: 1->2->3解题思路如果当前...
  • 链表删除重复元素
  • 自己1:行吧,时间已经击败99%的人了,不想优化了,bingo # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None class Solution(object):...
  • LeetCode- 删除排序链表中的重复元素 题目描述 存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除所有重复的元素,使每个元素 只出现一次 。 返回同样按升序排列的结果链表。 示例一: 示例二: ...
  • 题解: class Solution: def deleteDuplicates(self, head: ListNode) -> ListNode: if head == None: ... # 如果快指针没有走到链表尾部节点之后,则一直循环 while fast != None: if fast.val != s...
  • 比较暴力的解法,直接比较当前结点和下一个结点的值,相同则删除下一个结点,当前结点的next指针直接指到下下个结点上。 代码 # Definition for singly-linked list. # class ListNode(object): # def __init__(self...
  • 给定一个已排序的链表的头 , 删除原始链表中所有重复数字的节点,只留下不同的数字 。返回 已排序的链表 。示例 1: 示例 2: 提示:双指针,找没有重复的结点
  • 摘要在一个排序的链表中,存在重复的结点,请删除链表重复的结点,重复的结点不保留,返回链表头指针。一、前言本系列文章为《剑指Offer》刷题笔记。刷题平台:牛客网书籍下载:共享资源二、题目在一个排序的...
  • 题目描述在一个排序的链表中,存在重复的结点,请删除链表重复的结点,重复的结点不保留,返回链表头指针。 例如,链表1->2->3->3->4->4->5 处理后为 1->2->5思路有好几种方法,先讲两...
  • 删除排序链表中的重复元素 给定一个排序链表删除所有重复的元素,使得每个元素只出现一次。 举例: 如果q和q的下一个元素的值相同,直接跳过此元素,即: q.next=q.next.next 这时链表变成了: 这时再进行一次...
  • 题目1 原创文章 80获赞 39访问量 3万+ 关注 私信 展开阅读全文 作者:Leadingme
  • 在一个排序的链表中,存在重复的结点,请删除链表重复的结点,重复的结点不保留,返回链表头指针。 例如,链表1->2->3->3->4->4->5 处理后为 1->2->5 2、代码详解 # -*- coding:utf-8 -*- class ListNode: def...
  • 83.删除排序链表中的重复元素         给定一个排序链表删除所有重复的元素,使得每个元素只出现一次。 示例 1:         输入: 1->1->2       &...
  • 1.题中定义的链表head是指向第一个元素的指针,只要定义两个指针相比较,遇到重复的删去就行。 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = ...
  • 82.删除排序链表中的重复元素         给定一个排序链表删除所有含有重复数字的节点,只保留原始链表中 没有重复出现 的数字。 示例 1:         输入: 1->2->3->...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,195
精华内容 4,878
热门标签
关键字:

python删除链表重复元素