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

2025年03月17日 | 阅读 9 分钟

说明

在此程序中，我们将创建一个循环链表并从列表末尾删除一个节点。如果列表为空，将显示“列表为空”消息。如果列表不为空，我们将遍历列表直到到达倒数第二个节点。我们将倒数第二个节点设为新的尾节点，这个新的尾节点将指向头节点并删除原来的尾节点。

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

删除末尾节点后的循环链表

在此，上面的列表中，D 是需要删除的最后一个节点。我们将遍历到 C。将 C 设为新的尾节点，C 将重新指向头节点 A。

算法

定义一个 Node 类，它表示列表中的一个节点。它有两个属性 data 和 next，next 将指向下一个节点。
定义另一个类来创建循环链表，它有两个节点：head 和 tail。它有两个方法：deleteEnd() 和 display()。
deleteEnd() 将从列表末尾删除节点
1. 它首先检查 head 是否为 null（链表为空），然后，它将从函数返回，因为链表中没有节点。
2. 如果链表不为空，它将检查链表是否只有一个节点。
3. 如果列表只有一个节点，它将 head 和 tail 都设置为 null。
4. 如果列表包含多个节点，则遍历循环直到 current.next != tail。
5. 现在，current 将指向尾节点之前的节点。将 current 设为新的尾节点，tail 将指向 head，从而从末尾删除节点。
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;
    
    #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;
    
    #Deletes node from end of the list
    def deleteEnd(self):
        #Checks whether list is empty
        if(self.head == None):
            return;
        else:
            #Checks whether contain only one element
            if(self.head != self.tail ):
                current = self.head;
                #Loop will iterate till the second last element as current.next is pointing to tail
                while(current.next != self.tail):
                    current = current.next;
                #Second last element will be new tail
                self.tail = current;
                #Tail will point to head as it is a circular linked list
                self.tail.next = self.head;
            #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;
            
    #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.deleteEnd();
        #Printing updated list
        print("Updated List:");
        cl.display();

输出

Original List: 
 1 2 3 4
Updated List: 
 1 2 3
Updated List: 
 1 2
Updated List: 
 1
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;
};
 
//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;
    }
}
 
//Deletes node from end of the list
void deleteEnd() {
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Checks whether contain only one element
        if(head != tail ) {
            struct node *current = head;
            //Loop will iterate till the second last element as current.next is pointing to tail
            while(current->next != tail) {
                current = current->next;
            }
            //Second last element will be new tail
            tail = current;
            //Tail will point to head as it is a circular linked list
            tail->next = head;
        }
        //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;
        }
    }
}
    
//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) {
        deleteEnd();
        //Printing updated list
        printf("Updated List:\n ");
        display();
    }
   
   return 0;
}

输出

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

JAVA

public class DeleteEnd {
    //Represents the node of list.
    public class Node{
        int data;
        Node next;
        public Node(int data) {
            this.data = data;
        }
    }
    
    //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;
        }
    }
    
    //Deletes node from end of the list
    public void deleteEnd() {
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Checks whether contain only one element
            if(head != tail ) {
                Node current = head;
                //Loop will iterate till the second last element as current.next is pointing to tail
                while(current.next != tail) {
                    current = current.next;
                }
                //Second last element will be new tail
                tail = current;
                //Tail will point to head as it is a circular linked list
                tail.next = head;
            }
            //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;
            }
        }
    }
    
    //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) {
        DeleteEnd cl = new DeleteEnd();
        //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.deleteEnd();
            //Printing updated list
            System.out.println("Updated List: ");
            cl.display();
        }
    }
}

输出

Original List: 
 1 2 3 4
Updated List: 
 1 2 3
Updated List: 
 1 2
Updated List: 
 1
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 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;
                }
            }
            
            //Deletes node from end of the list
            public void deleteEnd() {
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Checks whether contain only one element
                    if(head != tail ) {
                        Node<T> current = head;
                        //Loop will iterate till the second last element as current.next is pointing to tail
                        while(current.next != tail) {
                            current = current.next;
                        }
                        //Second last element will be new tail
                        tail = current;
                        //Tail will point to head as it is a circular linked list
                        tail.next = head;
                    }
                    //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;
                    }
                }
            }
            
            //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.deleteEnd();
            //Printing updated list
            Console.WriteLine("Updated List: ");
            cl.display();
        }
        }    
    }
}

输出

Original List: 
 1 2 3 4
Updated List: 
 1 2 3
Updated List: 
 1 2
Updated List: 
 1
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 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;
        }
    }
    
    //Deletes node from end of the list
    function deleteEnd() {
        //Checks whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //Checks whether contain only one element
            if($this->head != $this->tail ) {
                $current = $this->head;
                //Loop will iterate till the second last element as current.next is pointing to tail
                while($current->next != $this->tail) {
                    $current = $current->next;
                }
                //Second last element will be new tail
                $this->tail = $current;
                //Tail will point to head as it is a circular linked list
                $this->tail->next = $this->head;
            }
            //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;
            }
        }
    }
    
    //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->deleteEnd();
    //Printing updated list
    echo "Updated List:<br>";
    $cl->display();
}
?>
</body>
</html>

输出

Original List: 
 1 2 3 4
Updated List: 
 1 2 3
Updated List: 
 1 2
Updated List: 
 1
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

相关帖子

编写查找六棱柱（Hexagonal Prism）面积的程序

查找数组中每个元素出现频率的程序

将天数转换为年的程序

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

在双向链表中搜索元素的程序

打印数字图案 5 的程序

确定给定数字是否为扭素数（Twisted prime number）的程序

计算矩形面积的程序

以升序对数组元素进行排序的程序

计算五边形面积的程序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器