数据结构示例-单向链表的中间插入新节点

📌 相关文章

📜 数据结构示例-单向链表的中间插入新节点

📅 最后修改于: 2020-10-15 04:48:52 🧑 作者: Mango

程序在单链列表的中间插入一个新节点

说明

在此程序中，我们将创建一个单链接列表，并在列表中间添加一个新节点。为了完成此任务，我们将计算列表的大小，然后将其除以2，以获取列表的中点，需要在其中插入新节点。

考虑上图；节点1代表原始列表的头。让node New是需要添加到列表中间的新节点。首先，我们计算大小(在这种情况下为4)。因此，要获得中点，我们将其除以2并将其存储在变量计数中。节点电流将指向头部。首先，我们遍历列表直到当前指向中间位置。定义另一个节点temp，该节点指向当前节点旁边的节点。在当前和临时之间插入新节点。

算法

创建一个具有两个属性的类Node：data和next。下一个是指向列表中下一个节点的指针。
创建另一个具有三个属性的InsertMid类：head，tail和size，它们跟踪列表中存在的多个节点。
addNode()将向列表添加一个新节点：
1. 创建一个新节点。
2. 它首先检查head是否等于null，这意味着列表为空。
3. 如果列表为空，则头和尾都将指向新添加的节点。
4. 如果列表不为空，则新节点将被添加到列表的末尾，使得尾部的下一个将指向新添加的节点。这个新节点将成为列表的新尾部。
addInMid()将在列表的中间添加一个新节点：
1. 它首先检查head是否等于null，这意味着列表为空。
2. 如果列表为空，则头和尾都将指向新添加的节点。
3. 如果列表不为空，则计算列表的大小，然后将其除以2得到列表的中点。
4. 定义节点电流，该电流将遍历列表，直到电流指向中间节点为止。
5. 定义另一个节点温度，该温度将指向当前节点旁边。
6. 新节点将在当前之后和temp之前插入，这样电流将指向新节点，而新节点将指向temp。
display()将显示列表中存在的节点：
1. 定义一个节点电流，该电流将初始指向列表的开头。
2. 遍历列表，直到当前指向null。
3. 通过在每次迭代中使电流指向其旁边的节点来显示每个节点。

示例：

Python

#Represent a node of the singly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.next = None;
        
class InsertMid:
    #Represent the head and tail of the singly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        self.size = 0;
        
    #addNode() will add a new node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #Checks if the list is empty
        if(self.head == None):
            #If list is empty, both head and tail will point to new node
            self.head = newNode;
            self.tail = newNode;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode will become new tail of the list
            self.tail = newNode;
        #Size will count the number of nodes present in the list
        self.size = self.size + 1;
        
    #This function will add the new node at the middle of the list.
    def addInMid(self, data):
        #Create a new node
        newNode = Node(data);
        
        #Checks if the list is empty
        if(self.head == None):
            #If list is empty, both head and tail would point to new node
            self.head = newNode;
            self.tail = newNode;
        else:
            #Store the mid position of the list
            count = (self.size//2) if(self.size % 2 == 0) else ((self.size+1)//2);
            #Node temp will point to head
            temp = self.head;
            current = None;
            
            #Traverse through the list till the middle of the list is reached
            for i in range(0, count):
                #Node current will point to temp
                current = temp;
                #Node temp will point to node next to it.
                temp = temp.next;
            
            #current will point to new node
            current.next = newNode;
            #new node will point to temp
            newNode.next = temp;
        self.size = self.size + 1;
            
    #display() will display all the nodes present in the list
    def display(self):
        #Node current will point to head
        current = self.head;
        
        if(self.head == None):
            print("List is empty");
            return;
            
        while(current != None):
            #Prints each node by incrementing pointer
            print(current.data)
            current = current.next;
        
 
sList = InsertMid();
        
#Adds data to the list
sList.addNode(1);
sList.addNode(2);
 
print("Original list: ");
sList.display();
 
#Inserting node '3' in the middle
sList.addInMid(3);
print( "Updated List: ");
sList.display();
 
#Inserting node '4' in the middle
sList.addInMid(4);
print("Updated List: ");
sList.display();

输出：

 Original list: 
1 2 
Updated List: 
1 3 2 
Updated List: 
1 3 4 2

C

#include 
 
//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
int size;
//Represent the head and tail of the singly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a new node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    newNode->next = NULL;
    
    //Checks if the list is empty
    if(head == NULL) {
        //If list is empty, both head and tail will point to new node
        head = newNode;
        tail = newNode;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode will become new tail of the list
        tail = newNode;
    }
    //Size will count the number of nodes present in the list
    size++;
}
 
//This function will add the new node at the middle of the list.
void addInMid(int data){
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    newNode->next = NULL;
    
    //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;
    }
    else {
        struct node *temp, *current;
        //Store the mid position of the list
        int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
        //Node temp will point to head
        temp = head;
        current = NULL;
 
        //Traverse through the list till the middle of the list is reached
        for(int i = 0; i < count; i++) {
            //Node current will point to temp
            current = temp;
            //Node temp will point to node next to it.
            temp = temp->next;
        }
        
        //current will point to new node
        current->next = newNode;
        //new node will point to temp
        newNode->next = temp;
    }
    size++;
}
    
//display() will display all the nodes present in the list
void display() {
    //Node current will point to head
    struct node *current = head;
    
    if(head == NULL) {
        printf("List is empty\n");
        return;
    }
    while(current != NULL) {
        //Prints each node by incrementing pointer
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}
    
int main()
{
    //Adds data to the list
    addNode(1);
    addNode(2);
    
    printf("Original list: \n");
    display();
    
    //Inserting node '3' in the middle
    addInMid(3);
    printf( "Updated List: \n");
    display();
    
    //Inserting node '4' in the middle
    addInMid(4);
    printf("Updated List: \n");
    display();
    
    return 0;
}

输出：

Original list: 
1 2 
Updated List: 
1 3 2 
Updated List: 
1 3 4 2

JAVA

public class InsertMid {
    
    //Represent a node of the singly linked list
    class Node{
        int data;
        Node next;
        
        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
 
    public int size;
    //Represent the head and tail of the singly linked list
    public Node head = null;
    public Node tail = null;
    
    //addNode() will add a new node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //Checks if the list is empty
        if(head == null) {
            //If list is empty, both head and tail will point to new node
            head = newNode;
            tail = newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode will become new tail of the list
            tail = newNode;
        }
        //Size will count the number of nodes present in the list
        size++;
    }
    
    //This function will add the new node at the middle of the list.
    public void addInMid(int data){
        //Create a 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;
        }
        else {
            Node temp, current;
            //Store the mid position of the list
            int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
            //Node temp will point to head
            temp = head;
            current = null;
 
            //Traverse through the list till the middle of the list is reached
            for(int i = 0; i < count; i++) {
                //Node current will point to temp
                current = temp;
                //Node temp will point to node next to it.
                temp = temp.next;
            }
            
            //current will point to new node
            current.next = newNode;
            //new node will point to temp
            newNode.next = temp;
        }
        size++;
    }
    
    //display() will display all the nodes present in the list
    public void display() {
        //Node current will point to head
        Node current = head;
        if(head == null) {
            System.out.println("List is empty");
            return;
        }
        
        while(current != null) {
            //Prints each node by incrementing pointer
            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        InsertMid sList = new InsertMid();
        
        //Adds data to the list
        sList.addNode(1);
        sList.addNode(2);
        
        System.out.println("Original list: ");
        sList.display();
        
        //Inserting node '3' in the middle
        sList.addInMid(3);
        System.out.println( "Updated List: ");
        sList.display();
        
        //Inserting node '4' in the middle
        sList.addInMid(4);
        System.out.println("Updated List: ");
        sList.display();
    }
}

输出：

Original list: 
1 2 
Updated List: 
1 3 2 
Updated List: 
1 3 4 2

C＃

using System;
                    
public class CreateList
{
    //Represent a node of the singly linked list
    public class Node{
        public T data;
        public Node next;
        
        public Node(T value) {
            data = value;
            next = null;
        }
    }
        
    public class InsertMid{
        public int size;
        //Represent the head and tail of the singly linked list
        public Node head = null;             
         public Node tail = null;
    
        //addNode() will add a new node to the list
        public void addNode(T data) {
            //Create a new node
            Node newNode = new Node(data);
 
            //Checks if the list is empty
            if(head == null) {
                //If list is empty, both head and tail will point to new node
                head = newNode;
                tail = newNode;
            }
            else {
                //newNode will be added after tail such that tail's next will point to newNode
                tail.next = newNode;
                //newNode will become new tail of the list
                tail = newNode;
            }
            //Size will count the number of nodes present in the list
            size++;
        }
 
        //This function will add the new node at the middle of the list.
        public void addInMid(T data){
            //Create a 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;
            }
            else {
                Node temp, current;
                //Store the mid position of the list
                int count = (size % 2 == 0) ? (size/2) : ((size+1)/2);
                //Node temp will point to head
                temp = head;
                current = null;
 
                //Traverse through the list till the middle of the list is reached
                for(int i = 0; i < count; i++) {
                    //Node current will point to temp
                    current = temp;
                    //Node temp will point to node next to it.
                    temp = temp.next;
                }
 
                //current will point to new node
                current.next = newNode;
                //new node will point to temp
                newNode.next = temp;
            }
            size++;
        }
 
        //display() will display all the nodes present in the list
        public void display() {
            //Node current will point to head
            Node current = head;
            if(head == null) {
                Console.WriteLine("List is empty");
                return;
            }
 
            while(current != null) {
                //Prints each node by incrementing pointer
                Console.Write(current.data + " ");
                current = current.next;
            }
            Console.WriteLine();
        }
    }
    
    public static void Main()
    {
        InsertMid sList = new InsertMid();
        
        //Adds data to the list
        sList.addNode(1);
        sList.addNode(2);
        
        Console.WriteLine("Original list: ");
        sList.display();
        
        //Inserting node '3' in the middle
        sList.addInMid(3);
        Console.WriteLine( "Updated List: ");
        sList.display();
        
        //Inserting node '4' in the middle
        sList.addInMid(4);
        Console.WriteLine("Updated List: ");
        sList.display();
    }
}

输出：

Original list: 
1 2 
Updated List: 
1 3 2 
Updated List: 
1 3 4 2

PHP：




data = $data;
        $this->next = NULL;
    }
}
class InsertMid{
    //Represent the head and tail of the singly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    
    //addNode() will add a new node to the list
    function addNode($data) {
        //Create a new node
        $newNode = new Node($data);
        
        //Checks if the list is empty
        if($this->head == null) {
            //If list is empty, both head and tail will point to new node
            $this->head = $newNode;
            $this->tail = $newNode;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode will become new tail of the list
            $this->tail = $newNode;
        }
        //Size will count the number of nodes present in the list
        $this->size++;
    }
    
    //This function will add the new node at the middle of the list.
    function addInMid($data){
        //Create a 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;
        }
        else {
            //Store the mid position of the list
            $count = ($this->size % 2 == 0) ? ($this->size/2) : (($this->size+1)/2);
            //Node temp will point to head
            $temp = $this->head;
            $current = null;
 
            //Traverse through the list till the middle of the list is reached
            for($i = 0; $i < $count; $i++) {
                //Node current will point to temp
                $current = $temp;
                //Node temp will point to node next to it.
                $temp = $temp->next;
            }
            
            //current will point to new node
            $current->next = $newNode;
            //new node will point to temp
            $newNode->next = $temp;
        }
        $this->size++;
    }
    
    //display() will display all the nodes present in the list
    function display() {
        //Node current will point to head
        $current = $this->head;
        
        if($this->head == NULL) {
            print("List is empty 
");
            return;
        }
        while($current != NULL) {
            //Prints each node by incrementing pointer
            print($current->data . " ");
            $current = $current->next;
        }
        print("
");
    }
}
 
$sList = new InsertMid();
 
//Adds data to the list
$sList->addNode(1);
$sList->addNode(2);
 
print("Original list: 
");
$sList->display();
 
//Inserting node '3' in the middle
$sList->addInMid(3);
print( "Updated List: 
");
$sList->display();
 
//Inserting node '4' in the middle
$sList->addInMid(4);
print("Updated List: 
");
$sList->display();
?>

输出：

Original list: 
1 2 
Updated List: 
1 3 2 
Updated List: 
1 3 4 2