Python 词典自动整理？

我正在尝试从排序的链表中删除重复项，例如

[1,2,3,3,4,4,5,6,6,6]

->

[1,2,5]

。有人能浏览一下代码并告诉我链接列表

2

->

1

->

None

的

a

的最终值是多少吗。它应该是

{2:1，1:1}

，但答案是

{1:1，2:1}

…为什么？

尝试以下方法：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None:
            return None
        start = head
        prev = head.val
        a = {prev:1}
        #o = [prev]
        head = head.next
        while head != None:
            if head.val == prev:
                a[prev] += 1
            else:
                prev = head.val
                a[prev] = 1
                #o.append(prev)
            head = head.next
        b = ListNode(0)
        ans = b
        for i in a: # can use for i in o
            if a[i] == 1:
                c = ListNode(i)
                b.next = c
                b = b.next
        return ans.next

这将保留

l

中项目的顺序。此答案假设您只想创建另一个列表，只保留出现一次的值

一种方法是使用from

itertools

，然后根据每组的长度进行过滤

>>> l = [1,2,3,3,4,4,5,6,6,6]
>>> [i for i in l if l.count(i) == 1]

编辑再次阅读您的问题，似乎此解决方案可能不起作用，除非您使用的链表类型符合迭代器协议。无论如何，它肯定不会生成一个列表作为输出，尽管您可以用生成器表达式替换列表理解并从中构建一个链表。

O（N）选项使用

---

dict

对象不记得添加到字典中的元素的顺序。如果您想保留可以使用的元素的顺序。

这里有一种在

O（n）

time（在Python 3中）中的方法，不管列表是否已排序

>>> from itertools import groupby
>>> [k for k,g in groupby([1,2,3,3,4,4,5,6,6,6]) if len(list(g)) == 1]
[1, 2, 5]

• lst:…中项的语句是

  O（n）

  。
  • unique中的表达式

    项是
    O（1）

  • 语句

    unique[item]=1

    是

    O（1）

    ，因此

    unique[item]+=1

• 表达式

  [k代表k，v在unique.items（）中如果v==1]

  是

  O（n）

因此，计算

for

语句的时间复杂度：

O（n）*（O（1）+max（O（1），O（1）））

O（n）*（O（1）+O（1））

O（n）*O（1）

O（n）

---

将其添加到列表理解的时间复杂度中，就得到了

O（n）+O（n）

，即

O（2n）

。去掉常数，你就有了

O（n）

不要创建不必要的类。解决方案是一个完全无用的类。列表已经排序了吗？不，不，你不明白。忽略无关的东西不是我们的工作，而是你的工作，但从根本上说，你的问题：“{2:1,1:1}但答案是{1:1,2:1}”没有任何意义：那些是等价的字典。Python

dict

是无序的。如果顺序很重要，请使用

collections.orderedict

这是O（N^2）。我试图用线性时间来解决这个问题。如果你关心性能，那么你需要更具体地了解你的情况，例如，如果列表中的项目总是排序的，等等。@NikhilRanjan的人们正在尝试帮助你。如果你不愿意为他们做同样的事情，他们为什么要对你有耐心？看起来你认为这是每个人的错，他们无法从你令人敬畏的问题中猜出你想要什么。这需要对列表进行排序，尽管如此，但如果我理解了这个问题，这是一个先决条件。很难说OP想要什么：“自动排序”有点模糊。谢谢，这就是我要找的。

>>> from itertools import groupby
>>> [k for k,g in groupby([1,2,3,3,4,4,5,6,6,6]) if len(list(g)) == 1]
[1, 2, 5]

>>> lst = [1, 2, 3, 3, 4, 4, 5, 6, 6, 6]
>>> unique = {}
>>> for item in lst:
...     if item in unique:
...         unique[item] += 1
...     else:
...         unique[item] = 1
... 
>>> [k for k, v in unique.items() if v == 1]
[1, 2, 5]