数据结构示例-删除单向链表中重复的元素

📌 相关文章

📜 数据结构示例-删除单向链表中重复的元素

📅 最后修改于: 2020-10-15 04:49:06 🧑 作者: Mango

程序从单链列表中删除重复的元素

说明

在此程序中，我们需要从给定的单链列表中删除重复的节点。

原始清单：

删除重复节点后的列表：

在上面的列表中，节点2重复三次，节点1重复两次。当前节点将指向头，索引将指向当前节点。开始遍历列表，直到找到重复项，即当前数据等于索引数据。在上面的示例中，第一个副本位于位置4。将电流分配给另一个节点temp。将temp的下一个节点与索引的下一个节点连接。删除指向重复节点的索引。此过程将继续进行，直到删除所有重复项。

算法

创建一个具有两个属性的类Node：data和next。下一个是指向列表中下一个节点的指针。
创建另一个具有两个属性的类RemoveDuplicate：head和tail。
addNode()将向列表添加一个新节点：
1. 创建一个新节点。
2. 它首先检查head是否等于null，这意味着列表为空。
3. 如果列表为空，则头和尾都将指向新添加的节点。
4. 如果列表不为空，则新节点将被添加到列表的末尾，使得尾部的下一个将指向新添加的节点。这个新节点将成为列表的新尾部。
removeDuplicate()将从列表中删除重复的节点。
1. 定义一个新的节点电流，该电流最初将指向头部。
2. 节点温度将指向当前节点，索引将始终指向当前节点旁边。
3. 循环浏览列表，直到当前指向null为止。
4. 检查当前数据是否等于索引数据，这意味着索引与当前数据重复。
5. 由于索引指向重复节点，因此通过使temp旁边的节点指向索引旁边的节点来跳过它，即temp.next = index.next。
display()将显示列表中存在的节点：
1. 定义一个节点电流，该电流将初始指向列表的开头。
2. 遍历列表，直到当前指向null。
3. 通过在每次迭代中使电流指向其旁边的节点来显示每个节点。

示例：

Python

#Represent a node of the singly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;
        
class RemoveDuplicate:
    #Represent the head and tail of the singly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        
    #addNode() will add a new node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #Checks if the list is empty
        if(self.head == None):
            #If list is empty, both head and tail will point to new node
            self.head = newNode;
            self.tail = newNode;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode will become new tail of the list
            self.tail = newNode;
            
    #removeDuplicate() will remove duplicate nodes from the list
    def removeDuplicate(self):
        #Node current will point to head
        current = self.head;
        index = None;
        temp = None;
        
        if(self.head == None):
            return;
        else:
            while(current != None):
                #Node temp will point to previous node to index.
                temp = current;
                #Index will point to node next to current
                index = current.next;
                
                while(index != None):
                    #If current node's data is equal to index node's data
                    if(current.data == index.data):
                        #Here, index node is pointing to the node which is duplicate of current node
                        #Skips the duplicate node by pointing to next node
                        temp.next = index.next;
                    else:
                        #Temp will point to previous node of index.
                        temp = index;
                    index = index.next;
                current = current.next;
                
    #display() will display all the nodes present in the list
    def display(self):
        #Node current will point to head
        current = self.head;
        if(self.head == None):
            print("List is empty");
            return;
        while(current != None):
            #Prints each node by incrementing pointer
            print(current.data);
            current = current.next;
        
 
sList = RemoveDuplicate();
        
#Adds data to the list
sList.addNode(1);
sList.addNode(2);
sList.addNode(3);
sList.addNode(2);
sList.addNode(2);
sList.addNode(4);
sList.addNode(1);
 
print("Originals list: ");
sList.display();
 
#Removes duplicate nodes
sList.removeDuplicate();
 
print("List after removing duplicates: ");
sList.display();

输出：

 Originals list: 
1 2 3 2 2 4 1 
List after removing duplicates: 
1 2 3 4

C

#include 

//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
//Represent the head and tail of the singly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a new node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    newNode->next = NULL;
    
    //Checks if the list is empty
    if(head == NULL) {
        //If list is empty, both head and tail will point to new node
        head = newNode;
        tail = newNode;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode will become new tail of the list
        tail = newNode;
    }
}
 
//removeDuplicate() will remove duplicate nodes from the list
void removeDuplicate() {
    //Node current will point to head
    struct node *current = head, *index = NULL, *temp = NULL;
    
    if(head == NULL) {
        return;
    }
    else {
        while(current != NULL){
            //Node temp will point to previous node to index.
            temp = current;
            //Index will point to node next to current
            index = current->next;
            
            while(index != NULL) {
                //If current node's data is equal to index node's data
                if(current->data == index->data) {
                    //Here, index node is pointing to the node which is duplicate of current node
                    //Skips the duplicate node by pointing to next node
                    temp->next = index->next;
                }
                else {
                    //Temp will point to previous node of index.
                    temp = index;
                }
                index = index->next;
            }
            current = current->next;
        }        
    }
}
 
//display() will display all the nodes present in the list
void display() {
    //Node current will point to head
    struct node *current = head;
    if(head == NULL) {
        printf("List is empty \n");
        return;
    }
    while(current != NULL) {
        //Prints each node by incrementing pointer
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}
    
int main()
{
    //Adds data to the list
    addNode(1);
    addNode(2);
    addNode(3);
    addNode(2);
    addNode(2);
    addNode(4);
    addNode(1);
    
    printf("Originals list: \n");
    display();
    
    //Removes duplicate nodes
    removeDuplicate();
    
    printf("List after removing duplicates: \n");
    display();
        
    return 0;
}

输出：

Originals list: 
1 2 3 2 2 4 1 
List after removing duplicates: 
1 2 3 4

JAVA

public class RemoveDuplicate {
    
    //Represent a node of the singly linked list
    class Node{
        int data;
        Node next;
        
        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
 
    //Represent the head and tail of the singly linked list
    public Node head = null;
    public Node tail = null;
    
    //addNode() will add a new node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //Checks if the list is empty
        if(head == null) {
            //If list is empty, both head and tail will point to new node
            head = newNode;
            tail = newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode will become new tail of the list
            tail = newNode;
        }
    }
    
    //removeDuplicate() will remove duplicate nodes from the list
    public void removeDuplicate() {
        //Node current will point to head
        Node current = head, index = null, temp = null;
        
        if(head == null) {
            return;
        }
        else {
            while(current != null){
                //Node temp will point to previous node to index.
                temp = current;
                //Index will point to node next to current
                index = current.next;
                
                while(index != null) {
                    //If current node's data is equal to index node's data
                    if(current.data == index.data) {
                        //Here, index node is pointing to the node which is duplicate of current node
                        //Skips the duplicate node by pointing to next node
                        temp.next = index.next;
                    }
                    else {
                        //Temp will point to previous node of index.
                        temp = index;
                    }
                    index = index.next;
                }
                current = current.next;
            }        
        }
    }
    
    //display() will display all the nodes present in the list
    public void display() {
        //Node current will point to head
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
            return;
        }
        while(current != null) {
            //Prints each node by incrementing pointer
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        RemoveDuplicate sList = new RemoveDuplicate();
        
        //Adds data to the list
        sList.addNode(1);
        sList.addNode(2);
        sList.addNode(3);
        sList.addNode(2);
        sList.addNode(2);
        sList.addNode(4);
        sList.addNode(1);
        
        System.out.println("Originals list: ");
        sList.display();
        
        //Removes duplicate nodes
        sList.removeDuplicate();
        
        System.out.println("List after removing duplicates: ");
        sList.display();
    }
}

输出：

Originals list: 
1 2 3 2 2 4 1 
List after removing duplicates: 
1 2 3 4

C＃

using System;
                    
public class CreateList
{
    //Represent a node of the singly linked list
    public class Node{
        public T data;
        public Node next;
        
        public Node(T value) {
            data = value;
            next = null;
        }
    }
        
    public class RemoveDuplicate{
        //Represent the head and tail of the singly linked list
        public Node head = null;             
         public Node tail = null;
    
        //addNode() will add a new node to the list
        public void addNode(T data) {
            //Create a new node
            Node newNode = new Node(data);
 
            //Checks if the list is empty
            if(head == null) {
                //If list is empty, both head and tail will point to new node
                head = newNode;
                tail = newNode;
            }
            else {
                //newNode will be added after tail such that tail's next will point to newNode
                tail.next = newNode;
                //newNode will become new tail of the list
                tail = newNode;
            }
        }
    
        //removeDuplicate() will remove duplicate nodes from the list
        public void removeDuplicate() {
            //Node current will point to head
            Node current = head, index = null, temp = null;
 
            if(head == null) {
                return;
            }
            else {
                while(current != null){
                    //Node temp will point to previous node to index.
                    temp = current;
                    //Index will point to node next to current
                    index = current.next;
 
                    while(index != null) {
                        //If current node's data is equal to index node's data
                        if(current.data.Equals(index.data)) {
                            //Here, index node is pointing to the node which is duplicate of current node
                            //Skips the duplicate node by pointing to next node
                            temp.next = index.next;
                        }
                        else {
                            //Temp will point to previous node of index.
                            temp = index;
                        }
                        index = index.next;
                    }
                    current = current.next;
                }        
            }
        }
        
        //display() will display all the nodes present in the list
        public void display() {
            //Node current will point to head
            Node current = head;
            if(head == null) {
                Console.WriteLine("List is empty");
                return;
            }
            while(current != null) {
                //Prints each node by incrementing pointer
                Console.Write(current.data + " ");
                current = current.next;
            }
            Console.WriteLine();
        }
    }
    
    public static void Main()
    {
        RemoveDuplicate sList = new RemoveDuplicate();
        
        //Adds data to the list
        sList.addNode(1);
        sList.addNode(2);
        sList.addNode(3);
        sList.addNode(2);
        sList.addNode(2);
        sList.addNode(4);
        sList.addNode(1);
        
        Console.WriteLine("Originals list: ");
        sList.display();
        
        //Removes duplicate nodes
        sList.removeDuplicate();
        
        Console.WriteLine("List after removing duplicates: ");
        sList.display();
    }
}

输出：

Originals list: 
1 2 3 2 2 4 1 
List after removing duplicates: 
1 2 3 4

PHP：




data = $data;
        $this->next = NULL;
    }
}
class RemoveDuplicate{
    //Represent the head and tail of the singly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    
    //addNode() will add a new node to the list
    function addNode($data) {
        //Create a new node
        $newNode = new Node($data);
        
        //Checks if the list is empty
        if($this->head == NULL) {
            //If list is empty, both head and tail will point to new node
            $this->head = $newNode;
            $this->tail = $newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode will become new tail of the list
            $this->tail = $newNode;
        }
    }
    
    //removeDuplicate() will remove duplicate nodes from the list
    function removeDuplicate() {
        //Node current will point to head
        $current = $this->head;
        $index = null;
        $temp = null;
        
        if($this->head == null) {
            return;
        }
        else {
            while($current != null){
                //Node temp will point to previous node to index.
                $temp = $current;
                //Index will point to node next to current
                $index = $current->next;
                
                while($index != null) {
                    //If current node's data is equal to index node's data
                    if($current->data == $index->data) {
                        //Here, index node is pointing to the node which is duplicate of current node
                        //Skips the duplicate node by pointing to next node
                        $temp->next = $index->next;
                    }
                    else {
                        //Temp will point to previous node of index.
                        $temp = $index;
                    }
                    $index = $index->next;
                }
                $current = $current->next;
            }        
        }
    }
    
    //display() will display all the nodes present in the list
    function display() {
        //Node current will point to head
        $current = $this->head;
        
        if($this->head == NULL) {
            print("List is empty 
");
            return;
        }
        while($current != NULL) {
            //Prints each node by incrementing pointer
            print($current->data . " ");
            $current = $current->next;
        }
        print("
");
    }
}
    
$sList = new RemoveDuplicate();
        
//Adds data to the list
$sList->addNode(1);
$sList->addNode(2);
$sList->addNode(3);
$sList->addNode(2);
$sList->addNode(2);
$sList->addNode(4);
$sList->addNode(1);
 
print("Originals list: 
");
$sList->display();
 
//Removes duplicate nodes
$sList->removeDuplicate();
 
print("List after removing duplicates: 
");
$sList->display();
?>

输出：

 Originals list: 
1 2 3 2 2 4 1 
List after removing duplicates: 
1 2 3 4