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

📌 相关文章

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

📅 最后修改于: 2020-10-15 05:31:46 🧑 作者: Mango

问：程序从双链表中删除重复的元素。

说明

在此程序中，我们将创建一个双向链接列表，并通过遍历列表来删除重复项(如果存在)。

原始清单：

删除重复项后的列表：

在上面的列表中，节点2被重复三次，节点3被重复两次。当前将指向头，索引将指向当前旁边的节点。开始遍历列表，直到找到重复项，即当前数据等于索引数据。在上面的示例中，第一个副本位于位置4。将索引分配给另一个节点temp。将索引的上一个节点与索引的下一个节点连接。删除指向重复节点的温度。该过程将一直持续到所有重复项都被删除为止。

算法

定义一个Node类，该类代表列表中的一个节点。它具有三个属性：数据，前一个将指向上一个节点，下一个将指向下一个节点。
定义另一个用于创建双向链接列表的类，它具有两个节点：head和tail。最初，头和尾将指向null。
addNode()将节点添加到列表中：
1. 它首先检查head是否为空，然后将节点插入为head。
2. 头部和尾部都将指向新添加的节点。
3. 头的前一个指针将指向空，而头的下一个指针将指向空。
4. 如果head不为null，则新节点将插入列表的末尾，以使新节点的前一个指针指向尾。
5. 新的节点将成为新的尾巴。尾巴的下一个指针将指向null。
removeDuplicateNode()将从列表中删除重复的节点。
1. 定义一个新的节点电流，该电流最初将指向头部。
2. 节点索引将始终指向当前节点旁边。
3. 循环浏览列表，直到当前指向null为止。
4. 检查当前数据是否等于索引数据，这意味着索引与当前数据重复。
5. 节点温度将指向索引以存储重复的节点。
6. 索引的前一个节点将指向索引的下一个节点。
7. 由于temp指向索引，索引是一个重复节点，因此请将temp设置为null。
display()将显示列表中存在的所有节点。
1. 定义一个新节点“当前”，该节点将指向头部。
2. 打印current.data直到current指向null。
3. 当前将在每次迭代中指向列表中的下一个节点。

示例：

Python

#Represent a node of doubly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.previous = None;
        self.next = None;
        
class RemoveDuplicate:
    #Represent the head and tail of the doubly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        
    #addNode() will add a node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #If list is empty
        if(self.head == None):
            #Both head and tail will point to newNode
            self.head = self.tail = newNode;
            #head's previous will point to None
            self.head.previous = None;
            #tail's next will point to None, as it is the last node of the list
            self.tail.next = None;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode's previous will point to tail
            newNode.previous = self.tail;
            #newNode will become new tail
            self.tail = newNode;
            #As it is last node, tail's next will point to None
            self.tail.next = None;
            
    #removeDuplicateNode() will remove duplicate nodes from the list
    def removeDuplicateNode(self):
        
        #Checks whether list is empty
        if(self.head == None):
            return;
        else:
            #Initially, current will point to head node
            current = self.head;
            while(current != None):
                #index will point to node next to current
                index = current.next
                while(index != None):
                    if(current.data == index.data):
                        #Store the duplicate node in temp
                        temp = index;
                        #index's previous node will point to node next to index thus, removes the duplicate node
                        index.previous.next = index.next;
                        if(index.next != None):
                            index.next.previous = index.previous;
                        #Delete duplicate node by making temp to None
                        temp = None;
                    index = index.next;
                current = current.next;
                        
    #display() will print out the nodes of 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;
        print();
        
dList = RemoveDuplicate();
#Add nodes to the list
dList.addNode(1);
dList.addNode(2);
dList.addNode(3);
dList.addNode(2);
dList.addNode(2);
dList.addNode(4);
dList.addNode(5);
dList.addNode(3);
 
print("Originals list: ");
dList.display();
 
#Removes duplicate nodes
dList.removeDuplicateNode();
 
print("List after removing duplicates: ");
dList.display();

输出：

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

C

#include 
 
//Represent a node of the doubly linked list

struct node{
    int data;
    struct node *previous;
    struct node *next;
};    
 
//Represent the head and tail of the doubly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    
    //If list is empty
    if(head == NULL) {
        //Both head and tail will point to newNode
        head = tail = newNode;
        //head's previous will point to NULL
        head->previous = NULL;
        //tail's next will point to NULL, as it is the last node of the list
        tail->next = NULL;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode's previous will point to tail
        newNode->previous = tail;
        //newNode will become new tail
        tail = newNode;
        //As it is last node, tail's next will point to NULL
        tail->next = NULL;
    }
}
 
//removeDuplicateNode() will remove duplicate nodes from the list
void removeDuplicateNode() {
    //Node current will point to head
    struct node *current, *index, *temp;
    
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Initially, current will point to head node
        for(current = head; current != NULL; current = current->next) {
            //index will point to node next to current
            for(index = current->next; index != NULL; index = index->next) {
                if(current->data == index->data) {
                    //Store the duplicate node in temp
                    temp = index;
                    //index's previous node will point to node next to index thus, removes the duplicate node
                    index->previous->next = index->next;
                    if(index->next != NULL)
                        index->next->previous = index->previous;
                    //Delete duplicate node by making temp to NULL
                    temp = NULL;
                }
            }
        }
    }
}
 
//display() will print out the nodes of 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()
{
    //Add nodes to the list
    addNode(1);
    addNode(2);
    addNode(3);
    addNode(2);
    addNode(2);
    addNode(4);
    addNode(5);
    addNode(3);
    
    printf("Originals list: \n");
    display();
    
    //Removes duplicate nodes
    removeDuplicateNode();
    
    printf("List after removing duplicates: \n");
    display();
 
    return 0;
}

输出：

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

JAVA

public class RemoveDuplicate {
    
    //Represent a node of the doubly linked list

    class Node{
        int data;
        Node previous;
        Node next;
        
        public Node(int data) {
            this.data = data;
        }
    }
    
    //Represent the head and tail of the doubly linked list
    Node head, tail = null;
    
    //addNode() will add a node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //If list is empty
        if(head == null) {
            //Both head and tail will point to newNode
            head = tail = newNode;
            //head's previous will point to null
            head.previous = null;
            //tail's next will point to null, as it is the last node of the list
            tail.next = null;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode's previous will point to tail
            newNode.previous = tail;
            //newNode will become new tail
            tail = newNode;
            //As it is last node, tail's next will point to null
            tail.next = null;
        }
    }
    
    //removeDuplicateNode() will remove duplicate nodes from the list
    public void removeDuplicateNode() {
        //Node current will point to head
        Node current, index, temp;
        
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Initially, current will point to head node
            for(current = head; current != null; current = current.next) {
                //index will point to node next to current
                for(index = current.next; index != null; index = index.next) {
                    if(current.data == index.data) {
                        //Store the duplicate node in temp
                        temp = index;
                        //index's previous node will point to node next to index thus, removes the duplicate node
                        index.previous.next = index.next;
                        if(index.next != null)
                            index.next.previous = index.previous;
                        //Delete duplicate node by making temp to null
                        temp = null;
                    }
                }
            }
        }
    }
    
    //display() will print out the nodes of 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 the pointer.

            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        RemoveDuplicate dList = new RemoveDuplicate();
        //Add nodes to the list
        dList.addNode(1);
        dList.addNode(2);
        dList.addNode(3);
        dList.addNode(2);
        dList.addNode(2);
        dList.addNode(4);
        dList.addNode(5);
        dList.addNode(3);
        
        System.out.println("Originals list: ");
        dList.display();
        
        //Removes duplicate nodes
        dList.removeDuplicateNode();
        
        System.out.println("List after removing duplicates: ");
        dList.display();
    }
}

输出：

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

C＃

using System; 
namespace DoublyLinkedList 
{                     
    public class Program
    {
        //Represent a node of the doubly linked list

        public class Node{
            public T data;
            public Node previous;
            public Node next;
            
            public Node(T value) {
                data = value;
            }
        }
        
        public class RemoveDuplicate{
            //Represent the head and tail of the doubly linked list
            protected Node head = null;             
             protected Node tail = null;
            
            //addNode() will add a node to the list
            public void addNode(T data) {
                //Create a new node
                Node newNode = new Node(data);
 
                //If list is empty
                if(head == null) {
                    //Both head and tail will point to newNode
                    head = tail = newNode;
                    //head's previous will point to null
                    head.previous = null;
                    //tail's next will point to null, as it is the last node of the list
                    tail.next = null;
                }
                else {
                    //newNode will be added after tail such that tail's next will point to newNode
                    tail.next = newNode;
                    //newNode's previous will point to tail
                    newNode.previous = tail;
                    //newNode will become new tail
                    tail = newNode;
                    //As it is last node, tail's next will point to null
                    tail.next = null;
                }
            }
            
            //removeDuplicateNode() will remove duplicate nodes from the list
            public void removeDuplicateNode() {
                //Node current will point to head
                Node current, index, temp;
 
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Initially, current will point to head node
                    for(current = head; current != null; current = current.next) {
                        //index will point to node next to current
                        for(index = current.next; index != null; index = index.next) {
                            if(current.data.Equals(index.data)) {
                                //Store the duplicate node in temp
                                temp = index;
                                //index's previous node will point to node next to index thus, removes the duplicate node
                                index.previous.next = index.next;
                                if(index.next != null)
                                    index.next.previous = index.previous;
                                //Delete duplicate node by making temp to null
                                temp = null;
                            }
                        }
                    }
                }
            }
    
            //display() will print out the nodes of 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 the pointer.

                    Console.Write(current.data + " ");
                    current = current.next;
                }
                Console.WriteLine();
            }
        }
        
        public static void Main()
        {
            RemoveDuplicate dList = new RemoveDuplicate();
            //Add nodes to the list
            dList.addNode(1);
            dList.addNode(2);
            dList.addNode(3);
            dList.addNode(2);
            dList.addNode(2);
            dList.addNode(4);
            dList.addNode(5);
            dList.addNode(3);
 
            Console.WriteLine("Originals list: ");
            dList.display();
 
            //Removes duplicate nodes
            dList.removeDuplicateNode();
 
            Console.WriteLine("List after removing duplicates: ");
            dList.display();
        }    
    }
}

输出：

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

PHP：




data = $data;
    }
}
class RemoveDuplicate{
    //Represent the head and tail of the doubly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    
    //addNode() will add a node to the list
    function addNode($data){
        //Create a new node
        $newNode = new Node($data);
        
        //If list is empty
        if($this->head == NULL) {
            //Both head and tail will point to newNode
            $this->head = $this->tail = $newNode;
            //head's previous will point to NULL
            $this->head->previous = NULL;
            //tail's next will point to NULL, as it is the last node of the list
            $this->tail->next = NULL;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode's previous will point to tail
            $newNode->previous = $this->tail;
            //newNode will become new tail
            $this->tail = $newNode;
            //As it is last node, tail's next will point to NULL
            $this->tail->next = NULL;
        }
    }
    
    //removeDuplicateNode() will remove duplicate nodes from the list
    function removeDuplicateNode() {        
        //Checks whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //Initially, current will point to head node
            for($current = $this->head; $current != NULL; $current = $current->next) {
                //index will point to node next to current
                for($index = $current->next; $index != NULL; $index = $index->next) {
                    if($current->data == $index->data) {
                        //Store the duplicate node in temp
                        $temp = $index;
                        //index's previous node will point to node next to index thus, removes the duplicate node
                        $index->previous->next = $index->next;
                        if($index->next != NULL)
                            $index->next->previous = $index->previous;
                        //Delete duplicate node by making temp to NULL
                        $temp = NULL;
                    }
                }
            }
        }
    }
    
    //display() will print out the nodes of 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("
");
    }
}
    
$dList = new RemoveDuplicate();
//Add nodes to the list
$dList->addNode(1);
$dList->addNode(2);
$dList->addNode(3);
$dList->addNode(2);
$dList->addNode(2);
$dList->addNode(4);
$dList->addNode(5);
$dList->addNode(3);
 
print("Originals list: 
");
$dList->display();
 
//Removes duplicate nodes
$dList->removeDuplicateNode();
 
print("List after removing duplicates: 
");
$dList->display();
?>

输出：

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