Question

我在代码下运行以从链接列表中删除重复项。但我的代码只删除重复项之前打印链接列表。一旦调用removeDup方法，它就不会打印任何内容。以下是我的代码。请告诉我我错过了什么。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def insert(self, data):
        node = Node(data)
        node.next=self.head
        self.head = node

    def printl(self):
        current  = self.head
        while current:
            print current.data
            current= current.next

    def removeDups(self):
        current = self.head
        while current is not None:
            second = current.next
            while second:
                if second.data == current.data:
                    current.next = second.next.next

                second = second.next
            current = current.next
#        l.printl()


l= LinkedList()
l.insert(15)
l.insert(14)
l.insert(16)
l.insert(15)
l.insert(15)
l.insert(14)
l.insert(18)
l.insert(159)
l.insert(12)
l.insert(10)
l.insert(15)
l.insert(14)

l.printl()
print "==============="

l.removeDups()
l.printl()

Answer 1

您删除找到的重复项目的逻辑是不对的。它会导致您删除第一次出现的值和过去最后一次出现的点之间的所有项目。对于您的示例列表，这会导致单个项目14在重复数据删除运行后打印（它从第一个值之后切换到最后一个值，尽管它也会在此过程中进行一些较小的切割）。

这是removeDups方法的固定版本。

def removeDups(self):
    current = second = self.head
    while current is not None:
        while second.next is not None:   # check second.next here rather than second
            if second.next.data == current.data:   # check second.next.data, not second.data
                second.next = second.next.next   # cut second.next out of the list
            else:
                second = second.next   # put this line in an else, to avoid skipping items
        current = second = current.next

主要变化是second指向之前的节点我们实际上有兴趣检查的第二个节点。我们在second.next完成所有工作。我们需要保留对second的引用，以便我们可以轻松地从列表中删除second.next。这样做需要我们在切断节点时不要提前second，因此second = second.next行必须在else子句中。< / p>

由于current和second在每次更新current后始终以相同的值开头，因此我更改了逻辑以在单个语句中分配它们。它会以原始的方式工作，我只是觉得这样看起来更好。

Answer 2

我认为使用“第二”变量令人困惑。

def removeDups(self):
    current = self.head
    while current: #First loop
        while current.next and current.data == current.next.data: #Second loop
            current.next = current.next.next #Deletion
        current = current.next

您从列表的开头开始，对于列表中的每个节点，直到您在末尾（当前时为）都单击“无”，您将进入另一个循环。循环检查以确保存在下一个节点（current.next时为），以及下一个节点是否具有与当前节点相同的数据（ current.data == current.next）。数据）。每当第二个循环为真时，就表示我们有一个重复项。下一行（ current.next = current.next.next ）是实际删除的内容。它还方便地将current.next更新为我们要比较的列表中的下一个节点，以便第二个循环可以立即再次检查以查看是否还有另一个重复项。一旦第二个循环找到并删除了该特定节点的所有重复项，我们将跳至下一行（ current = current.next ），将当前节点更新为下一个并开始检查该节点重复。

Answer 3

我们可以使用列表或字典来检查插入的项目是否已经存在

class Node:
  def __init__(self,data):
    self.data=data
    self.next=None

class LinkedList:
  def __init__(self):
    self.head=None

  def append(self,data):
    new_Node=Node(data)
    if self.head is None:
      self.head=new_Node
      return
    last_node=self.head
    while last_node.next:
      last_node=last_node.next
    last_node.next=new_Node

  def printing(self):
    current_node=self.head
    while current_node:
      print(current_node.data)
      current_node=current_node.next

  def remove_dup(self):
    curr=self.head
    glist=[]                        #list to store the values
    while curr:
      if curr.data in glist:        #checking the value already exists in list
        prev.next=curr.next
      else:
        glist.append(curr.data)
        prev=curr
      curr=curr.next

llist=LinkedList()
llist.append(1)
llist.append(6)
llist.append(1)
llist.append(4)
llist.append(2)
llist.append(2)
llist.append(4)
llist.remove_dup()
llist.printing()

Answer 4

这是应如何编写removeDuplicates函数的方式：

class node:
    def __init__(self):
        self.data = None
        self.next = None
class Linked_List:
    def __init__(self):
        self.head = None
    def get_head(self):
        return self.head
    def insert(self, data):
        if self.head == None:
            self.head = node()
            self.head.data = data
        else:
            new_node = node()
            new_node.data = data
            new_node.next = None
            temp = self.head
            while(temp.next):
                temp=temp.next
            temp.next = new_node
    def printlist(self):
        temp = self.head
        while temp!=None:
            print(temp.data, end=" ")
            temp= temp.next

def removeDuplicates(head):
    current = head
    element_list = []
    prev = None
    while (current is not None):
        if current.data not in element_list:
            element_list.append(current.data)
            prev = current
            current = current.next
        else:
            prev.next = current.next
            current = current.next


if __name__ == '__main__':
    values_list = [[5,2,2,4], [2,2,2,2,2]]
    t = len(values_list)
    for index in range(t):
        list1 = Linked_List()
        for i in values_list[index]:
            list1.insert(i)
        print('Input:')
        list1.printlist()
        print()
        removeDuplicates(list1.head)
        print('Output')
        list1.printlist()
        print('')

它从排序/未排序的单链列表中删除重复的节点

Answer 5

您可以使用其他数据结构来保存唯一值（例如列表）

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None


class LinkedList:
    def __init__(self):
        self.head = None

    def insert_node(self, data):
        new_node = Node(data)
        if self.head is None:
            self.head = new_node
        else:
            new_node.next = self.head
            self.head = new_node

    def remove_dups(self):
        uniques = []
        prev = None
        curr = self.head
        while curr is not None:
            if curr.data in uniques:
                prev.next = curr.next
            else:
                uniques.append(curr.data)
                prev = curr
            curr = curr.next

    def print_list(self):
        output = ""
        tmp = self.head
        while tmp is not None:
            output += str(tmp.data) + " "
            tmp = tmp.next
        print(output)

`

从链接列表Python中删除重复项

5 个答案: