📌  相关文章
📜  数据结构示例-循环链表的开头插入新节点

📅  最后修改于: 2020-10-15 06:03:30             🧑  作者: Mango

问：程序在循环链表的开头插入一个新节点。

说明

在此程序中，我们将创建一个循环链接列表，并将每个新节点插入列表的开头。如果列表为空，则头和尾将指向新添加的节点。如果列表不为空，则将头的数据存储到临时节点temp中，并以新节点作为头。这个新头将指向临时节点。简而言之，新添加的节点将成为列表的第一个节点(头)，而先前的head(临时)将成为列表的第二个节点。

在将新节点插入列表的开头之后

New表示新添加的节点。较早的A是列表的头。当将new添加到列表的开头时，new将成为新的标题，并且将指向先前的标题，即A。

算法

  • 定义一个Node类，该类代表列表中的一个节点。它具有两个属性数据，下一个将指向下一个节点。
  • 定义另一个用于创建循环链接列表的类，它具有两个节点：head和tail。它有两种方法：addAtStart()和display()。
  • addAtStart()会将节点添加到列表的开头：
    1. 它首先检查head是否为空(空列表)，然后将节点插入为head。
    2. 头部和尾部都将指向新添加的节点。
    3. 如果列表不为空，则新添加的节点将成为新的头，并且将指向先前的头。
  • display()将显示列表中存在的所有节点。
    1. 定义一个新节点“当前”，该节点将指向头部。
    2. 打印current.data，直到current再次指向head。
    3. 当前将在每次迭代中指向列表中的下一个节点。

示例：

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 at the start of the list.
  def addAtStart(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:
        #Store data into temporary node
        temp = self.head;
        #New node will point to temp as next node
        newNode.next = temp;
        #New node will be the head node
        self.head = newNode;
        #Since, it is circular linked list tail will point to head.
        self.tail.next = self.head;
 
  #Displays all the nodes in the list
  def display(self):
    current = self.head;
    if self.head is None:
      print("List is empty");
      return;
    else:
        print("Adding nodes to the start of the list: ");
        #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();
  
  #Adding 1 to the list
  cl.addAtStart(1);
  cl.display();
  #Adding 2 to the list
  cl.addAtStart(2);
  cl.display();
  #Adding 3 to the list
  cl.addAtStart(3);
  cl.display();
  #Adding 4 to the list
  cl.addAtStart(4);
  cl.display();

输出：

Adding nodes to the start of the list: 
1
Adding nodes to the start of the list: 
2 1
Adding nodes to the start of the list: 
3 2 1
Adding nodes to the start of the list: 
4 3 2 1

C

#include 
#include 
#include 
 
//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 to the start of the list.
void addAtStart(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 {
        //Store data into temporary node
        struct node *temp = head;
        //New node will point to temp as next node
        newNode->next = temp;
        //New node will be the head node
        head = newNode;
        //Since, it is circular linked list tail will point to head.
        tail->next = head;
    }
}
 
//This function will display the nodes of circular linked list
void display(){
    struct node *current = head;
    if(head == NULL){
        printf("List is empty");
    }
    else{
        printf("Adding nodes to the start of the list: \n");
         do{
             //Prints each node by incrementing pointer.
            printf("%d ", current->data);
            current = current->next;
        }while(current != head);
        printf("\n");
    }
}
    
int main()
{
   //Adding 1 to the list
   addAtStart(1);
   display();
   //Adding 2 to the list
   addAtStart(2);
   display();
   //Adding 3 to the list
   addAtStart(3);
   display();
   //Adding 4 to the list
   addAtStart(4);
   display();
   
   return 0;
}

输出：

Adding nodes to the start of the list: 
1
Adding nodes to the start of the list: 
2 1
Adding nodes to the start of the list: 
3 2 1
Adding nodes to the start of the list: 
4 3 2 1

JAVA

public class InsertAtStart {
    //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 addAtStart(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 {
                //Store data into temporary node
                Node temp = head;
                //New node will point to temp as next node
                newNode.next = temp;
                //New node will be the head node
                head = newNode;
                //Since, it is circular linked list tail will point to head.
                tail.next = head;
            }
        }
        
        //Displays all the nodes in the list
        public void display() {
            Node current = head;
            if(head == null) {
                System.out.println("List is empty");
            }
            else {
                System.out.println("Adding nodes to the start of the list: ");
                 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) {
            InsertAtStart cl = new InsertAtStart();
            
            //Adding 1 to the list
            cl.addAtStart(1);
            cl.display();
            //Adding 2 to the list
            cl.addAtStart(2);
            cl.display();
            //Adding 3 to the list
            cl.addAtStart(3);
            cl.display();
            //Adding 4 to the list
            cl.addAtStart(4);
            cl.display();
        }
}

输出：

Adding nodes to the start of the list: 
1
Adding nodes to the start of the list: 
2 1
Adding nodes to the start of the list: 
3 2 1
Adding nodes to the start of the list: 
4 3 2 1

C＃

using System; 
namespace CircularLinkedList 
{                     
    public class Program
    {
        //Represents the node of list.
        public class Node{
            public T data;
            public Node next;
            public Node(T value) {
                data = value;
                next = null;
            }
        }
        
        public class CreateList{
            protected Node head = null;             
             protected Node tail = null;
            
            //This function will add the new node to the start of the list.
            public void addAtStart(T data){
                //Create new node
                Node newNode = new Node(data);
                //Checks if the list is empty.
                if(head == null){
                    head = newNode;
                    tail = newNode;
                    newNode.next = head;
                    
                }else{
                    
                    //Store data into temporary node
                    Node temp = head;
                    //New node will point to temp as next node
                    newNode.next = temp;
                    //New node will be the head node
                    head = newNode;
                    //Since, it is circular linked list tail will point to head.
                    tail.next = head;
                }
    
            }
            //Displays all the nodes in the list
            public void display(){
                Node current = head;
                if(head == null){
                    Console.WriteLine("List is empty");
                }
                else{
                    Console.WriteLine("Adding nodes to the start of the list: ");
                    do{
                        //Prints each node by incrementing pointer.
                        Console.Write(" "+ current.data);
                        current = current.next;
                }while(current != head);
                    
                Console.WriteLine();
                }    
            }
        }
        
        public static void Main()
        {
            
        CreateList cl = new CreateList();
            
        //Adding 1 to the list
        cl.addAtStart(1);
        cl.display();
        //Adding 2 to the list
        cl.addAtStart(2);
        cl.display();
        //Adding 3 to the list
        cl.addAtStart(3);
        cl.display();
        //Adding 4 to the list
        cl.addAtStart(4);
        cl.display();
        
        }    
    }
}

输出：

 Adding nodes to the start of the list: 
1
Adding nodes to the start of the list: 
2 1
Adding nodes to the start of the list: 
3 2 1
Adding nodes to the start of the list: 
4 3 2 1

PHP：




data = $data;
        $this->next = NULL;
    }
}
class CreateList{
    //Declaring head and tail pointer as null.
    private $head;
    private $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    //This function will add the new node at the start of the list.
    function addAtStart($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{
            //Store data into temporary node
            $temp = $this->head;
            //New node will point to temp as next node
            $newNode->next = $temp;
            //New node will be the head node
            $this->head = $newNode;
            //Since, it is circular linked list tail will point to head.
            $this->tail->next = $this->head;
        }
    }
    //Displays all the nodes in the list
    function display() {
        $current = $this->head;
        if($this->head == NULL) {
            echo "List is empty";
        }
        else {
            echo "Adding nodes to the start of the list: 
";
             do{
                echo(" $current->data");
                $current = $current->next;
            }while($current != $this->head);
            echo "
";
        }
    }   
}
$cl = new CreateList();
//Adding 1 to the list
$cl->addAtStart(1);
$cl->display();
//Adding 2 to the list
$cl->addAtStart(2);
$cl->display();
//Adding 3 to the list
$cl->addAtStart(3);
$cl->display();
//Adding 4 to the list
$cl->addAtStart(4);
$cl->display();
?>

输出：

Adding nodes to the start of the list: 
1
Adding nodes to the start of the list: 
2 1
Adding nodes to the start of the list: 
3 2 1
Adding nodes to the start of the list: 
4 3 2 1