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

📌 相关文章

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

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

从单链列表中间删除新节点的程序

说明

在此程序中，我们将创建一个单链列表并从列表中间删除一个节点。为了完成此任务，我们将计算列表的大小，然后将其除以2得到列表的中点。节点温度将指向头节点。我们将遍历列表直到到达中点。现在，温度将指向中间节点，而节点当前将指向温度之前的节点。我们删除中间节点，以便当前的下一个节点将指向temp的下一个节点。

考虑上面的示例，上面列表的中点是2。从头到中点迭代温度。现在，temp指向需要删除的中间节点。在这种情况下，Node是需要删除的中间节点。可以通过使节点2的下一个(当前)指向节点3(临时的下一个节点)来删除该节点。将temp设置为null。

算法

创建一个具有两个属性的类Node：data和next。下一个是指向列表中下一个节点的指针。
创建另一个具有三个属性的DeleteMid类：head，tail和size，它们跟踪列表中存在的节点数。
addNode()将向列表添加一个新节点：
1. 创建一个新节点。
2. 它首先检查head是否等于null，这意味着列表为空。
3. 如果列表为空，头和尾都将指向新添加的节点。
4. 如果列表不为空，则新节点将被添加到列表的末尾，使得尾部的下一个将指向新添加的节点。这个新节点将成为列表的新尾部。
deleteFromMid()将从列表中间删除一个节点：
1. 它首先检查头是否为空(空列表)，然后显示消息“列表为空”并返回。
2. 如果列表不为空，它将检查列表是否只有一个节点。
3. 如果列表只有一个节点，则它将head和tail都设置为null。
4. 如果列表具有多个节点，则计算列表的大小，然后将其除以2得到列表的中点。
5. 声明一个节点温度，该温度将指向头部，节点当前电流将指向该温度之前的节点。
6. 遍历列表，直到temp指向中间节点。如果current不指向null，则通过将current_next指向temp的next来删除中间节点(temp)。否则，头和尾都将指向temp旁边的节点，并通过将temp设置为null来删除中间节点。
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 DeleteMid:
    #Represent the head and tail of the singly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        self.size = 0;
        
    #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;
        #Size will count the number of nodes present in the list
        self.size = self.size + 1;
            
    #deleteFromMid() will delete a node from the middle of the list
    def deleteFromMid(self):
        #Checks if list is empty
        if(self.head == None):
            print("List is empty");
            return;
        else:
            #Store the mid position of the list
            count = (self.size//2) if(self.size % 2 == 0)  else((self.size+1)//2);
            
            #Checks whether head is equal to tail or not, if yes then list has only one node.
            if( self.head != self.tail ):
                #Initially, temp will point to head
                temp = self.head;
                current = None;
                
                #Current will point to node previous to
                #If temp is pointing to node 2 then current will point to node 1.
                for i in range(0, count-1):
                    current = temp;
                    temp = temp.next;
                    
                if(current != None):
                    #temp is the middle that needs to be removed.
                    #So, current node will point to node next to temp by skipping temp.
                    current.next = temp.next;
                    #Delete temp
                    temp = None;
                #If current points to None then, head and tail will point to node next to temp.
                else:
                    self.head = self.tail = temp.next;
                    #Delete temp
                    temp = None;
            #If the list contains only one element
            #then it will remove it and both head and tail will point to None
            else:
                self.head = self.tail = None;
        self.size = self.size - 1;
                
    #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 = DeleteMid();
 
#Adds data to the list
sList.addNode(1);
sList.addNode(2);
sList.addNode(3);
sList.addNode(4);
 
#Printing original list
print("Original List: ");
sList.display();
 
while(sList.head != None):
    sList.deleteFromMid();
    #Printing updated list
    print("Updated List: ");
    sList.display();

输出：

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

C

#include 
 
//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
int size;
//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;
    }
    //Size will count the number of nodes present in the list
    size++;
}
 
//deleteFromMid() will delete a node from the middle of the list
void deleteFromMid() {
    struct node *temp, *current;
    
    //Checks if list is empty
    if(head == NULL) {
        printf("List is empty \n");
        return;
    }
    else {
        //Store the mid position of the list
        int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
        
        //Checks whether the head is equal to the tail or not, if yes then the list has only one node.
        if( head != tail ) {
            //Initially, temp will point to head
            temp = head;
            current = NULL;
            
            //Current will point to node previous to temp
            //If temp is pointing to node 2 then current will point to node 1.
            for(int i = 0; i < count-1; i++){
                current = temp;
                temp = temp->next;
            }                
            if(current != NULL) {
                //temp is the middle that needs to be removed.
                //So, current node will point to node next to temp by skipping temp.
                current->next = temp->next;
                //Delete temp
                temp = NULL;
            }
            //If current points to NULL then, head and tail will point to node next to temp.
            else {
                head = tail = temp->next;
                //Delete temp
                temp = NULL;
            }    
        }
        //If the list contains only one element 
        //then it will remove it and both head and tail will point to NULL
        else {
            head = tail = NULL;
        }
    }
    size--;
}
    
//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(4);
    
    //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 
Updated List: 
1 3 4 
Updated List: 
1 4 
Updated List: 
4 
Updated List: 
List is empty

JAVA

#include 
 
//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
int size;
//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;
    }
    //Size will count the number of nodes present in the list
    size++;
}
 
//deleteFromMid() will delete a node from the middle of the list
void deleteFromMid() {
    struct node *temp, *current;
    
    //Checks if list is empty
    if(head == NULL) {
        printf("List is empty \n");
        return;
    }
    else {
        //Store the mid position of the list
        int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
        
        //Checks whether the head is equal to the tail or not, if yes then the list has only one node.
        if( head != tail ) {
            //Initially, temp will point to head
            temp = head;
            current = NULL;
            
            //Current will point to node previous to temp
            //If temp is pointing to node 2 then current will point to node 1.
            for(int i = 0; i < count-1; i++){
                current = temp;
                temp = temp->next;
            }                
            if(current != NULL) {
                //temp is the middle that needs to be removed.
                //So, current node will point to node next to temp by skipping temp.
                current->next = temp->next;
                //Delete temp
                temp = NULL;
            }
            //If current points to NULL then, head and tail will point to node next to temp.
            else {
                head = tail = temp->next;
                //Delete temp
                temp = NULL;
            }    
        }
        //If the list contains only one element 
        //then it will remove it and both head and tail will point to NULL
        else {
            head = tail = NULL;
        }
    }
    size--;
}
    
//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(4);
    
    //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 
Updated List: 
1 3 4 
Updated List: 
1 4 
Updated List: 
4 
Updated List: 
List is empty

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 DeleteMid{
        public int size;
        //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;
            }
            //Size will count the number of nodes present in the list
            size++;
        }
    
        //deleteFromMid() will delete a node from the middle of the list
        public void deleteFromMid() {
            Node temp, current;
 
            //Checks if list is empty
            if(head == null) {
                Console.WriteLine("List is empty");
                return;
            }
            else {
                //Store the mid position of the list
                int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
 
                //Checks whether the head is equal to the tail or not, if yes then the list has only one node.
                if( head != tail ) {
                    //Initially, temp will point to head
                    temp = head;
                    current = null;
 
                    //Current will point to node previous to temp
                    //If temp is pointing to node 2 then current will point to node 1.
                    for(int i = 0; i < count-1; i++){
                        current = temp;
                        temp = temp.next;
                    }                
                    if(current != null) {
                        //temp is the middle that needs to be removed.
                        //So, current node will point to node next to temp by skipping temp.
                        current.next = temp.next;
                        //Delete temp
                      temp = null;
                    }
                    //If current points to null then, head and tail will point to node next to temp.
                    else {
                        head = tail = temp.next;
                        //Delete temp
                        temp = null;
                    }    
                }
                //If the list contains only one element 
                //then it will remove it and both head and tail will point to null
                else {
                    head = tail = null;
                }
            }
            size--;
        }
        
        //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()
    {
        DeleteMid sList = new DeleteMid();
        
        //Adds data to the list
        sList.addNode(1);
        sList.addNode(2);
        sList.addNode(3);
        sList.addNode(4);
        
        //Printing original list
        Console.WriteLine("Original List: ");
        sList.display();
        
        while(sList.head != null) {
            sList.deleteFromMid();
            //Printing updated list
            Console.WriteLine("Updated List: ");
            sList.display();
        }
    }
}

输出：

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

PHP：




data = $data;
        $this->next = NULL;
    }
}
class DeleteMid{
    //Represent the head and tail of the singly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    
    //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;
        }
        //Size will count the number of nodes present in the list
        $this->size++;
    }
    
    //deleteFromMid() will delete a node from the middle of the list
    function deleteFromMid() {
        
        //Checks if list is empty
        if($this->head == null) {
            print("List is empty 
");
            return;
        }
        else {
            //Store the mid position of the list
            $count = ($this->size % 2 == 0) ? ($this->size/2) : (($this->size+1)/2);
            
            //Checks whether head is equal to tail or not, if yes then list has only one node.
            if( $this->head != $this->tail ) {
                //Initially, temp will point to head
                $temp = $this->head;
                $current = null;
                
                //Current will point to node previous to temp
                //If temp is pointing to node 2 then current will point to node 1.
                for($i = 0; $i < $count-1; $i++){
                    $current = $temp;
                    $temp = $temp->next;
                }                
                if($current != null) {
                    //temp is the middle that needs to be removed.
                    //So, current node will point to node next to temp by skipping temp.
                    $current->next = $temp->next;
                    //Delete temp
                    $temp = null;
                }
                //If current points to null then, head and tail will point to node next to temp.
                else {
                    $this->head = $this->tail = $temp->next;
                    //Delete temp
                    $temp = null;
                }    
            }
            //If the list contains only one element 
            //then it will remove it and both head and tail will point to null
            else {
                $this->head = $this->tail = null;
            }
        }
        $this->size--;
    }
    
    //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 DeleteMid();
        
//Adds data to the list
$sList->addNode(1);
$sList->addNode(2);
$sList->addNode(3);
$sList->addNode(4);
 
//Printing original list
print("Original List: 
");
$sList->display();
 
while($sList->head != null) {
    $sList->deleteFromMid();
    //Printing updated list
    print("Updated List: 
");
    $sList->display();
}
?>

输出：

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