Java 从循环链表中间删除节点的程序

17 Mar 2025 | 4 分钟阅读

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

单位矩阵

Java program to delete a 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() 将从列表中删除中间节点
- 它首先检查 head 是否为 null（空列表），然后返回该函数，因为列表中不存在任何节点。
- 如果列表不为空，它将检查列表是否只有一个节点。
- 如果列表只有一个节点，它将 head 和 tail 都设置为 null。
- 如果列表包含多个节点，则计算列表的大小。将大小除以 2 并将其存储在变量 count 中。
- Temp 将指向 head，current 将指向 temp 的前一个节点。
- 遍历列表直到 current 指向列表的中间节点。
- Current 将指向 temp 后面的节点，即，删除 current 后面的节点。

a. display() 将显示列表中存在的所有节点。

定义一个新节点“current”，它将指向头节点。
打印 current.data 直到 current 再次指向 head。
在每次迭代中，current 将指向列表中的下一个节点。

程序

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

下一个主题Java 程序

Java 从循环链表中间删除节点的程序

算法

程序

联系信息

关注我们

教程

面试题

在线编译器

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

Java 程序

Java 从循环链表中间删除节点的程序

算法

程序

相关帖子

Java 对循环链表元素进行排序的程序

Java Program to Check if a Given Number is Perfect Square

Java 程序反转字符串中的每个单词

Java 判断两个字符串是否为回文的程序

查找具有 N 个键的可能二叉搜索树总数的 Java 程序

Java 中在角为 1 的矩阵中查找矩形

如何在 Java 中将 int 转换为字符串

查找二叉树最大宽度的 Java 程序

打印数组中重复元素的 Java 程序

如何在 Java 中将 double 转换为 int

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器