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

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

说明

在此程序中，我们将创建一个循环链表并从列表开头删除一个节点。如果列表为空，则打印消息“列表为空”。如果列表不为空，我们将使头指向列表中的下一个节点，即删除第一个节点。

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

从开头删除节点后的循环链表

在这里，A 代表列表的头部。我们需要从列表开头删除一个节点。因此，我们将删除 A，使 B 成为新的头部，尾部将指向新的头部。

算法

定义一个 Node 类，它表示列表中的一个节点。它有两个属性 data 和 next，next 将指向下一个节点。
定义另一个类来创建循环链表，它有两个节点：head 和 tail。它有两个方法：deleteStart() 和 display()。
deleteStart() 将从列表开头删除节点
1. 它首先检查 head 是否为 null（链表为空），然后，它将从函数返回，因为链表中没有节点。
2. 如果链表不为空，它将检查链表是否只有一个节点。
3. 如果列表只有一个节点，它将 head 和 tail 都设置为 null。
4. 如果列表中有多个节点，那么 head 将指向列表中的下一个节点，即删除前一个 head 节点，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 the beginning of the list
    def deleteStart(self):
        #Checks whether list is empty
        if(self.head == None):
            return;
        else:
            #Checks whether contain only one element
            #If not, head will point to next element in the list and tail will point to new head.
            if(self.head != self.tail ):
                self.head = self.head.next;
                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, end= ' ');
            while(current.next != self.head):
                current = current.next;
                print(current.data,end=' ');
            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.deleteStart();
        #Printing updated list
        print("Updated List:");
        cl.display();

输出

Original List: 
 1 2 3 4
Updated List: 
 2 3 4
Updated List: 
 3 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;
};
 
//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 the beginning of the list
void deleteStart() {
    //Checks whether list is empty
    if(head == NULL) {
        return;
    }
    else {
        //Checks whether contain only one element
        //If not, head will point to next element in the list and tail will point to new head.
        if(head != tail ) {
            head = head->next;
            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) {
       deleteStart();
       //Printing updated list
       printf("Updated List:\n ");
       display();
   }
   
   return 0;
}

输出

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

JAVA

public class DeleteStart {
    //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 the beginning of the list
    public void deleteStart() {
        //Checks whether list is empty
        if(head == null) {
            return;
        }
        else {
            //Checks whether contain only one element
            //If not, head will point to next element in the list and tail will point to new head.
            if(head != tail ) {
                head = head.next;
                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) {
        DeleteStart cl = new DeleteStart();
        //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.deleteStart();
            //Printing updated list
            System.out.println("Updated List: ");
            cl.display();
        }
    }
}

输出

Original List: 
 1 2 3 4
Updated List: 
 2 3 4
Updated List: 
 3 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 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 the beginning of the list
            public void deleteStart() {
                //Checks whether list is empty
                if(head == null) {
                    return;
                }
                else {
                    //Checks whether contain only one element
                    //If not, head will point to next element in the list and tail will point to new head.
                    if(head != tail ) {
                        head = head.next;
                        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.deleteStart();
            //Printing updated list
            Console.WriteLine("Updated List: ");
            cl.display();
        }
        }    
    }
}

输出

Original List: 
 1 2 3 4
Updated List: 
 2 3 4
Updated List: 
 3 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 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 the beginning of the list
    function deleteStart() {
        //Checks whether list is empty
        if($this->head == NULL) {
            return;
        }
        else {
            //Checks whether contain only one element
            //If not head, will point to next element in the list and tail will point to new head.
            if($this->head != $this->tail ) {
                $this->head = $this->head->next;
                $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->deleteStart();
    //Printing updated list
    echo "Updated List:<br>";
    $cl->display();
}
?>
</body>
</html>

输出

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

相关帖子

打印图案 7 的程序

从单向链表末尾删除节点的程序

显示数字三角形图案（19）的程序

将厘米转换为英尺和英寸的程序

计算五边形面积的程序

计算长方体表面积的程序

对双向链表元素进行排序的程序

从字符串中分离出单个字符的程序

打印数字图案 13 的程序

计算两个矩阵之和的程序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器