问：从循环链表中间删除新节点的程序。

2025年3月17日 | 阅读11分钟

说明

在此程序中，我们将创建一个循环链表并从链表的中间删除一个节点。如果链表为空，则显示消息“列表为空”。如果链表不为空，我们将计算链表的大小，然后将其除以 2 以获得链表的中间点。我们维护两个指针 temp 和 current。current 将指向 temp 的前一个节点。我们将遍历链表直到达到中间点，然后 current 将指向中间节点。我们删除中间节点，使得 current 的下一个节点是 temp 的下一个节点。

Program to delete a new node from the middle of the circular linked list

从链表中间删除节点后的循环链表

考虑上面的列表。列表的大小为 4。节点的中间点为 2。要从列表中删除 C，我们将遍历列表直到中间点。现在 current 将指向 B，temp 将指向 C。当 B 指向 D 时，C 将被删除。

算法

定义一个 Node 类，它表示列表中的一个节点。它有两个属性 data 和 next，next 将指向下一个节点。
定义另一个类来创建循环链表，它有两个节点：head 和 tail。它有一个变量 size 和两个方法：deleteMid() 和 display()。
deleteMid() 将从列表的中间删除节点
1. 它首先检查 head 是否为空（空列表），如果是，则由于列表中不存在节点，它将从函数返回。
2. 如果列表不为空，它将检查列表是否只有一个节点。
3. 如果列表只有一个节点，它将 head 和 tail 都设置为 null。
4. 如果列表有多个节点，它将计算列表的大小。将大小除以 2 并将其存储在变量 count 中。
5. temp 将指向 head，current 将指向 temp 的前一个节点。
6. 遍历列表直到 current 指向列表的中间节点。
7. current 将指向 temp 的下一个节点，即删除 current 的下一个节点。
display() 将显示列表中存在的所有节点。
1. 定义一个新节点“current”，它将指向头节点。
2. 打印 current.data 直到 current 再次指向 head。
3. 在每次迭代中，current 将指向列表中的下一个节点。

解决方案

Python

#Represents the node of list.
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;
 
class CreateList:
    #Declaring head and tail pointer as null.
    def __init__(self):
        self.head = Node(None);
        self.tail = Node(None);
        self.head.next = self.tail;
        self.tail.next = self.head;
        self.size = 0;
    
    #This function will add the new node at the end of the list.
    def add(self,data):
        newNode = Node(data);
        #Checks if the list is empty.
        if self.head.data is None:
            #If list is empty, both head and tail would point to new node.
            self.head = newNode;
            self.tail = newNode;
            newNode.next = self.head;
        else:
            #tail will point to new node.
            self.tail.next = newNode;
            #New node will become new tail.
            self.tail = newNode;
            #Since, it is circular linked list tail will point to head.
            self.tail.next = self.head;
        #Size will count the number of nodes in the list
        self.size = int(self.size)+1;
    
    #Deletes node from the middle of the list
    def deleteMid(self):
        #Checks whether list is empty
        if(self.head == None):
            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 temp
                #If temp is pointing to node 2 then current will points 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;
                #Current points to null then head and tail will point to node next to temp.
                else:
                    self.head = self.tail = temp.next;
                    self.tail.next = self.head;
                    #Delete temp;
                    temp = None;
            #If the list contains only one element 
            #then it will remove it and both head and tail will point to null
            else:
                self.head = self.tail = None;
        self.size = self.size - 1;
 
            
    #Displays all the nodes in the list
    def display(self):
        current = self.head;
        if self.head is None:
            print("List is empty");
            return;
        else:
            #Prints each node by incrementing pointer.
            print(current.data),
            while(current.next != self.head):
                current = current.next;
                print(current.data),
            print("\n");
 
class CircularLinkedList:
    cl = CreateList();
    #Adds data to the list
    cl.add(1);
    cl.add(2);
    cl.add(3);
    cl.add(4);
    #Printing original list
    print("Original List:");
    cl.display();
    while(cl.head != None):
        cl.deleteMid();
        #Printing updated list
        print("Updated List:");
        cl.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 <stdio.h>
#include <string.h>
#include <stdlib.h>
 
//Represents the node of list.
struct node{
    int data;
    struct node *next;
};
 
int size;
//Declaring head and tail pointer as null.
struct node *head = NULL;
struct node *tail = NULL;
 
//This function will add the new node at the end of the list.
void add(int data){
    //Create new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    //Checks if the list is empty.
    if(head == NULL){
        //If list is empty, both head and tail would point to new node.
        head = newNode;
        tail = newNode;
        newNode->next = head;
    }else {
        //tail will point to new node.
        tail->next = newNode;
        //New node will become new tail.
        tail = newNode;
        //Since, it is circular linked list tail will point to head.
        tail->next = head;
    }
    //Counts the number of nodes in list
    size++;
}
 
//Deletes node from the middle of the list
void deleteMid() {
    struct node *current, *temp;
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Store the mid position of the list
        int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
        //Checks whether head is equal to tail or not, if yes then 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 points 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;
            }
            //Current points to null then head and tail will point to node next to temp.
            else {
                head = tail = temp->next;
                tail->next = head;
                //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--;
}
    
//This function will display the nodes of circular linked list
void display(){
    struct node *current = head;
    if(head == NULL){
        printf("List is empty");
    }
    else{
         do{
             //Prints each node by incrementing pointer.
            printf("%d ", current->data);
            current = current->next;
        }while(current != head);
        printf("\n");
    }
}
    
int main()
{
   //Adds data to the list
   add(1);
   add(2);
   add(3);
   add(4);
   //Printing original list
   printf("Original List:\n ");
   display();
   while(head != NULL) {
        deleteMid();
        //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

public class DeleteMid {
    //Represents the node of list.
    public class Node{
        int data;
        Node next;
        public Node(int data) {
            this.data = data;
        }
    }
    
    public int size;
    //Declaring head and tail pointer as null.
    public Node head = null;
    public Node tail = null;
    
    //This function will add the new node at the end of the list.
    public void add(int data){
        //Create new node
        Node newNode = new Node(data);
        //Checks if the list is empty.
        if(head == null) {
             //If list is empty, both head and tail would point to new node.
            head = newNode;
            tail = newNode;
            newNode.next = head;
        }
        else {
            //tail will point to new node.
            tail.next = newNode;
            //New node will become new tail.
            tail = newNode;
            //Since, it is circular linked list tail will point to head.
            tail.next = head;
        }
        //Counts the number of nodes in list
        size++;
    }
    
    //Deletes node from the middle of the list
    public void deleteMid() {
        Node current, temp;
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Store the mid position of the list
            int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
            //Checks whether head is equal to tail or not, if yes then 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 points 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;
                }
                //Current points to null then head and tail will point to node next to temp.
                else {
                    head = tail = temp.next;
                    tail.next = head;
                    //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--;
    }
    
    //Displays all the nodes in the list
    public void display() {
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                System.out.print(" "+ current.data);
                current = current.next;
            }while(current != head);
            System.out.println();
        }
    }
    
    public static void main(String[] args) {
        DeleteMid cl = new DeleteMid();
        //Adds data to the list
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(4);
        //Printing original list
        System.out.println("Original List: ");
        cl.display();
        while(cl.head != null) {
            cl.deleteMid();
            //Printing updated list
            System.out.println("Updated List: ");
            cl.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#

using System; 
namespace CircularLinkedList 
{                     
    public class Program
    {
        //Represents the node of list.
        public class Node<T>{
            public T data;
            public Node<T> next;
            public Node(T value) {
                data = value;
                next = null;
            }
        }
        
        public class CreateList<T>{
            public int size = 0;
            public Node<T> head = null;             
             public Node<T> tail = null;
            
            //This function will add the new node at the end of the list.
            public void add(T data){
                //Create new node
                Node<T> newNode = new Node<T>(data);
                //Checks if the list is empty.
                if(head == null){
                    head = newNode;
                    tail = newNode;
                    newNode.next = head;
                }else{
                    //tail will point to new node.
                    tail.next = newNode;
                    //New node will become new tail.
                    tail = newNode;
                    //Since, it is circular linked list tail will point to head.
                    tail.next = head;
                }
                //Counts the number of nodes in the list
                size++;
            }
            
            //Deletes node from the middle of the list
            public void deleteMid() {
                Node<T> current, temp;
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Store the mid position of the list
                    int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
                    //Checks whether head is equal to tail or not, if yes then 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 points 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;
                        }
                        //Current points to null then head and tail will point to node next to temp.
                        else {
                            head = tail = temp.next;
                            tail.next = head;
                            //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--;
            }
            
            //Displays all the nodes in the list
            public void display(){
                Node<T> current = head;
                if(head == null){
                    Console.WriteLine("List is empty");
                }
                else{
                    do{
                        //Prints each node by incrementing pointer.
                        Console.Write(" "+ current.data);
                        current = current.next;
                    }while(current != head);
                    Console.WriteLine();
                }
            }
        }
        
        public static void Main()
        {
            
        CreateList<int> cl = new CreateList<int>();
        //Adds data to the list
        cl.add(1);
        cl.add(2);
        cl.add(3);
        cl.add(4);
        //Printing original list
        Console.WriteLine("Original List: ");
        cl.display();
        while(cl.head != null) {
            cl.deleteMid();
            //Printing updated list
            Console.WriteLine("Updated List: ");
            cl.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

<!DOCTYPE html>
<html>
<body>
<?php
//Represents the node of list.
class Node{
    public $data;
    public $next;
    function __construct($data){
        $this->data = $data;
        $this->next = NULL;
    }
}
class CreateList{
    //Declaring head and tail pointer as null.
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    //This function will add the new node at the end of the list.
    function add($data){
        //Create new node
        $newNode = new Node($data);
        //Checks if the list is empty.
        if($this->head == NULL){
            //If list is empty, both head and tail would point to new node.
            $this->head = $newNode;
            $this->tail = $newNode;
            $newNode->next = $this->head;
        }
        else{
            //tail will point to new node.
            $this->tail->next = $newNode;
            //New node will become new tail.
            $this->tail = $newNode;
            //Since, it is circular linked list tail will point to head.
            $this->tail->next = $this->head;
        }
        $this->size++;
    }
    
    //Deletes node from the middle of the list
    function deleteMid() {
        //Checks whether list is empty
        if($this->head == NULL) {
            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 points 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;
                }
                //Current points to null then head and tail will point to node next to temp.
                else {
                    $this->head = $this->tail = $temp->next;
                    $this->tail->next = $this->head;
                    //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--;
    }
    
    //Displays all the nodes in the list
    function display() {
        $current = $this->head;
        if($this->head == NULL) {
            echo "List is empty";
        }
        else {
             do{
                //Prints each node by incrementing pointer.
                echo(" $current->data");
                $current = $current->next;
            }while($current != $this->head);
            echo "<br>";
        }
    }   
}
$cl = new CreateList();
//Adds data to the list
$cl->add(1);
$cl->add(2);
$cl->add(3);
$cl->add(4);
//Printing original list
echo "Original List:<br>";
$cl->display();
while($cl->head != NULL) {
    $cl->deleteMid();
    //Printing updated list
    echo "Updated List:<br>";
    $cl->display();
}
?>
</body>
</html>

输出

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

下一主题#

问：从循环链表中间删除新节点的程序。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

程序

问：从循环链表中间删除新节点的程序。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

相关帖子

打印图案 3 的程序

打印给定字符串中最小和最大可能回文单词的程序

检查迪沙里数（Disarium number）的程序

在循环链表开头插入新节点的程序

单向链表示例

打印数字图案 6 的程序

检查快乐数（Happy number）的程序

确定给定数字是否为丰数（Abundant number）的程序

打印 1 到 100 之间的所有快乐数的程序

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

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器