数据结构示例-双向链表删除中间一个节点

📌 相关文章

📜 数据结构示例-双向链表删除中间一个节点

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

问：程序从双链表的中间删除一个新节点。

说明

在此程序中，我们将创建一个双向链接列表，并从列表中间删除一个节点。如果列表为空，则显示消息“列表为空”。如果列表不为空，我们将计算列表的大小，然后将其除以2得到列表的中点。电流将指向头节点。我们将遍历列表直到到达中点。现在，电流将指向中间节点。我们删除中间节点，使当前的上一个节点指向当前的下一个节点。

考虑上面的例子，上面列表的中点是3。迭代从头到中点的电流。现在，当前指向需要删除的中间节点。在这种情况下，new节点是需要删除的中间节点。可以通过使节点2(当前的上一个节点)指向节点3(当前的下一个节点)来删除New。将current设置为null。

算法

定义一个Node类，该类代表列表中的一个节点。它具有三个属性：数据，前一个将指向上一个节点，下一个将指向下一个节点。
定义另一个类来创建双向链表，它有两个节点：head和tail。最初，头和尾将指向null。
deleteFromMid()将从列表中间删除一个节点：
1. 它首先检查head是否为空(空列表)，然后它将从函数返回，因为列表中没有节点。
2. 如果列表不为空，它将检查列表是否只有一个节点。
3. 如果列表具有多个节点，则它将计算列表的大小。将大小除以2，然后将其存储在可变的mid中。
4. 遍历列表，直到当前指向列表的中间节点。
5. 将当前的上一个节点连接到当前的下一个节点。
6. 通过将其设置为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 DeleteMid:
    #Represent the head and tail of the doubly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        self.size = 0;
        
    #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;
        #Size will count the number of nodes present in the list
        self.size = self.size + 1;
        
    #deleteFromMid() will delete a node from middle of the list
    def deleteFromMid(self):
        #Checks whether list is empty
        if(self.head == None):
            return;
        else:
            #current will point to head
            current = self.head;
            
            #Store the mid position of the list
            mid = (self.size//2) if(self.size % 2 == 0) else((self.size+1)//2);
            
            #Iterate through list till current points to mid position
            for i in range(1, mid):
                current = current.next;
                
            #If middle node is head of the list
            if(current == self.head):
                self.head = current.next;
            #If middle node is tail of the list
            elif(current == self.tail):
                self.tail = self.tail.previous;
            else:
                current.previous.next = current.next;
                current.next.previous = current.previous;
            #Delete the middle node
            current = None;
        self.size = self.size - 1;    
    
    #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 = DeleteMid();
#Add nodes to the list
dList.addNode(1);
dList.addNode(2);
dList.addNode(3);
dList.addNode(4);
dList.addNode(5);
 
#Printing original list
print("Original List: ");
dList.display();
while(dList.head != None):
    dList.deleteFromMid();
    #Printing updated list
    print("Updated List: ")
    dList.display();

输出：

Original List: 
1 2 3 4 5 
Updated List: 
1 2 4 5 
Updated List: 
1 4 5 
Updated List: 
1 5 
Updated List: 
5 
Updated List: 
List is empty

C

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

struct node{
    int data;
    struct node *previous;
    struct node *next;
};    
 
int size = 0;
//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;
    }
    //Size will count the number of nodes present in the list
    size++;
}
 
//deleteFromMid() will delete a node from middle of the list
void deleteFromMid() {
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //current will point to head
        struct node *current = head;
        
        //Store the mid position of the list
        int mid = (size % 2 == 0) ? (size/2) : ((size+1)/2);    
        
        //Iterate through list till current points to mid position
        for(int i = 1; i < mid; i++){
            current = current->next;
        }
        
        //If middle node is head of the list
        if(current == head) {
            head = current->next;
        }
        //If middle node is tail of the list
        else if(current == tail) {
            tail = tail->previous;
        }
        else {
            current->previous->next = current->next;
            current->next->previous = current->previous;
        }
        //Delete the middle node
        current = NULL;
     }
    size--;        
}
 
//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(4);
    addNode(5);
    
    //Printing original list
    printf("Original List: \n");
    display();
    while(head != NULL) {
        deleteFromMid();
        //Printing updated list
        printf("Updated List: \n");
        display();
    }    
 
    return 0;
}

输出：

Original List: 
1 2 3 4 5 
Updated List: 
1 2 4 5 
Updated List: 
1 4 5 
Updated List: 
1 5 
Updated List: 
5 
Updated List: 
List is empty

JAVA

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

    class Node{
        int data;
        Node previous;
        Node next;
        
        public Node(int data) {
            this.data = data;
        }
    }
    
    public int size = 0;
    //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;
        }
        //Size will count the number of nodes present in the list
        size++;
    }
    
    //deleteFromMid() will delete a node from middle of the list
    public void deleteFromMid() {
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //current will point to head
            Node current = head;
            
            //Store the mid position of the list
            int mid = (size % 2 == 0) ? (size/2) : ((size+1)/2);    
            
            //Iterate through list till current points to mid position
            for(int i = 1; i < mid; i++){
                current = current.next;
            }
            
            //If middle node is head of the list
            if(current == head) {
                head = current.next;
            }
            //If middle node is tail of the list
            else if(current == tail) {
                tail = tail.previous;
            }
            else {
                current.previous.next = current.next;
                current.next.previous = current.previous;
            }
            //Delete the middle node
            current = null;
        }
        size--;        
    }
    
    //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) {
        
        DeleteMid dList = new DeleteMid();
        //Add nodes to the list
        dList.addNode(1);
        dList.addNode(2);
        dList.addNode(3);
        dList.addNode(4);
        dList.addNode(5);
        
        //Printing original list
        System.out.println("Original List: ");
        dList.display();
        while(dList.head != null) {
            dList.deleteFromMid();
            //Printing updated list
            System.out.println("Updated List: ");
            dList.display();
        }
    }
}

输出：

Original List: 
1 2 3 4 5 
Updated List: 
1 2 4 5 
Updated List: 
1 4 5 
Updated List: 
1 5 
Updated List: 
5 
Updated List: 
List is empty

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 DeleteMid{
            public int size = 0;
            //Represent the head and tail of the doubly linked list
            public Node head = null;             
             public 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;
                }
                //Size will count the number of nodes present in the list
                size++;
            }
    
            //deleteFromMid() will delete a node from middle of the list
            public void deleteFromMid() {
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //current will point to head
                    Node current = head;
 
                    //Store the mid position of the list
                    int mid = (size % 2 == 0) ? (size/2) : ((size+1)/2);    
 
                    //Iterate through list till current points to mid position
                    for(int i = 1; i < mid; i++){
                        current = current.next;
                    }
 
                    //If middle node is head of the list
                    if(current == head) {
                        head = current.next;
                    }
                    //If middle node is tail of the list
                    else if(current == tail) {
                        tail = tail.previous;
                    }
                    else {
                        current.previous.next = current.next;
                        current.next.previous = current.previous;
                    }
                    //Delete the middle node
                    current = null;
                }
                size--;        
            }
    
            //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()
        {
            DeleteMid dList = new DeleteMid();
            //Add nodes to the list
            dList.addNode(1);
            dList.addNode(2);
            dList.addNode(3);
            dList.addNode(4);
            dList.addNode(5);
 
            //Printing original list
            Console.WriteLine("Original List: ");
            dList.display();
            while(dList.head != null) {
                dList.deleteFromMid();
                //Printing updated list
                Console.WriteLine("Updated List: ");
                dList.display();
            }
        }    
    }
}

输出：

Original List: 
1 2 3 4 5 
Updated List: 
1 2 4 5 
Updated List: 
1 4 5 
Updated List: 
1 5 
Updated List: 
5 
Updated List: 
List is empty

PHP：




data = $data;
    }
}
class DeleteMid{
    //Represent the head and tail of the doubly linked list
    public $head;
    public $tail;
    public $size;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    
    //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;
        }
        //Size will count the number of nodes present in the list
        $this->size++;
    }
    
    //deleteFromMid() will delete a node from middle of the list
    function deleteFromMid() {
        //Checks whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //current will point to head
            $current = $this->head;
            
            //Store the mid position of the list
            $mid = ($this->size % 2 == 0) ? ($this->size/2) : (($this->size+1)/2);    
            
            //Iterate through list till current points to mid position
            for($i = 1; $i < $mid; $i++){
                $current = $current->next;
            }
            
            //If middle node is head of the list
            if($current == $this->head) {
                $this->head = $current->next;
            }
            //If middle node is tail of the list
            else if($current == $this->tail) {
                $this->tail = $this->tail->previous;
            }
            else {
                $current->previous->next = $current->next;
                $current->next->previous = $current->previous;
            }
            //Delete the middle node
            $current = NULL;
        }
        $this->size--;        
    }
    
    //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 DeleteMid();
//Add nodes to the list
$dList->addNode(1);
$dList->addNode(2);
$dList->addNode(3);
$dList->addNode(4);
$dList->addNode(5);
 
//Printing original list
print("Original List: 
");
$dList->display();
while($dList->head != NULL) {
    $dList->deleteFromMid();
    //Printing updated list
    print("Updated List: 
");
    $dList->display();
}
?>

输出：

Original List: 
1 2 3 4 5 
Updated List: 
1 2 4 5 
Updated List: 
1 4 5 
Updated List: 
1 5 
Updated List: 
5 
Updated List: 
List is empty