📌  相关文章
📜  数据结构示例-旋转n个节点的双向链表

📅  最后修改于: 2020-10-15 05:32:16             🧑  作者: Mango

问:程序旋转N个节点的双向链表。

说明

在此程序中,我们需要创建一个双向链接列表,并将其旋转n个节点。这可以通过维护从头节点开始并遍历列表直到当前指针指向第n个节点的指针来实现。将列表从头移到第n个节点,并将其放在尾部之后。现在,第n个节点将成为列表的尾部,第n个节点旁边的节点将成为新的头。在此,n应始终大于0但小于列表的大小。

原始清单:

将其旋转3个节点后的列表:

在上面的示例中,我们需要将列表旋转3个节点。首先,我们遍历列表,直到当前指向第三个节点,在本例中为第3个节点。将列表从节点1移到3,并将其放置在尾部之后。现在,节点4将成为新的头部,节点3将成为新的头部。

算法

  • 定义一个Node类,该类代表列表中的一个节点。它具有三个属性:数据,前一个将指向上一个节点,下一个将指向下一个节点。
  • 定义另一个类来创建双向链表,它有两个节点:head和tail。最初,头和尾将指向null。
  • addNode()将节点添加到列表中:
    1. 它首先检查head是否为空,然后将节点插入为head。
    2. 头部和尾部都将指向新添加的节点。
    3. 头的前一个指针将指向空,而头的下一个指针将指向空。
    4. 如果head不为null,则新节点将插入列表的末尾,以使新节点的前一个指针指向尾。
    5. 新的节点将成为新的尾巴。尾巴的下一个指针将指向null。
  • rotationList()将列表旋转给定的n个节点。
    1. 首先,检查n是否为0或大于或等于列表中存在的许多节点。
    2. 如果是,按原样print列表。
    3. 如果否,则定义一个节点电流,该电流将指向头部。
    4. 遍历列表直到电流到达第n个节点。
    5. 尾巴的下一个将指向头节点。
    6. 将当前节点旁边的节点设为新节点。 Head的前一个将指向null。
    7. 当前节点将成为列表的尾部。尾巴的下一个将指向null。
  • display()将显示列表中存在的所有节点。
    1. 定义一个新节点“当前”,该节点将指向头部。
    2. 打印current.data直到current指向null。
    3. 当前将在每次迭代中指向列表中的下一个节点。

示例:

Python

#Represent a node of doubly linked list
class Node:
    def __init__(self,data):
        self.data = data;
        self.previous = None;
        self.next = None;
        
class RotateList:
    #Represent the head and tail of the doubly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        self.size = 0;
        
    #addNode() will add a node to the list
    def addNode(self, data):
        #Create a new node
        newNode = Node(data);
        
        #If list is empty
        if(self.head == None):
            #Both head and tail will point to newNode
            self.head = self.tail = newNode;
            #head's previous will point to None
            self.head.previous = None;
            #tail's next will point to None, as it is the last node of the list
            self.tail.next = None;
        else:
            #newNode will be added after tail such that tail's next will point to newNode
            self.tail.next = newNode;
            #newNode's previous will point to tail
            newNode.previous = self.tail;
            #newNode will become new tail
            self.tail = newNode;
            #As it is last node, tail's next will point to None
            self.tail.next = None;
        #Size will count the number of nodes present in the list
        self.size = self.size + 1;
        
    #rotateList() will rotate the list by given n nodes
    def rotateList(self, n):
        #Initially, current will point to head
        current = self.head;
        
        #n should not be 0 or greater than or equal to number of nodes present in the list
        if(n == 0 or n >= self.size):
            return;
        else:
            #Traverse through the list till current point to nth node
            #after this loop, current will point to nth node
            for i in range(1, n):
                current = current.next;
                
            #Now to move entire list from head to nth node and add it after tail
            self.tail.next = self.head;
            #Node next to nth node will be new head
            self.head = current.next;
            #Previous node to head should be None
            self.head.previous = None;
            #nth node will become new tail of the list
            self.tail = current;
            #tail's next will point to None
            self.tail.next = None;
            
    #display() will print out the nodes of 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;
        print();
        
dList = RotateList();
#Add nodes to the list
dList.addNode(1);
dList.addNode(2);
dList.addNode(3);
dList.addNode(4);
dList.addNode(5);
 
print("Original List: ");
dList.display();
 
#Rotates list by 3 nodes
dList.rotateList(3);
 
print("Updated List: ");
dList.display();

输出:

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

C

#include 
 
//Represent a node of the doubly linked list

struct node{
    int data;
    struct node *previous;
    struct node *next;
};    
 
int size = 0;
//Represent the head and tail of the doubly linked list
struct node *head, *tail = NULL;
 
//addNode() will add a node to the list
void addNode(int data) {
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    
    //If list is empty
    if(head == NULL) {
        //Both head and tail will point to newNode
        head = tail = newNode;
        //head's previous will point to NULL
        head->previous = NULL;
        //tail's next will point to NULL, as it is the last node of the list
        tail->next = NULL;
    }
    else {
        //newNode will be added after tail such that tail's next will point to newNode
        tail->next = newNode;
        //newNode's previous will point to tail
        newNode->previous = tail;
        //newNode will become new tail
        tail = newNode;
        //As it is last node, tail's next will point to NULL
        tail->next = NULL;
    }
    //Size will count the number of nodes present in the list
    size++;
}
 
//rotateList() will rotate the list by given n nodes
void rotateList(int n) {
    //Initially, current will point to head
    struct node *current = head;
    
    //n should not be 0 or greater than or equal to number of nodes present in the list
    if(n == 0 || n >= size) 
        return;
    else {
        //Traverse through the list till current point to nth node
        //after this loop, current will point to nth node
        for(int i = 1; i < n; i++) 
            current = current->next;
        
        //Now to move entire list from head to nth node and add it after tail
        tail->next = head;
        //Node next to nth node will be new head
        head = current->next;
        //Previous node to head should be NULL
        head->previous = NULL;
        //nth node will become new tail of the list
        tail = current;
        //tail's next will point to NULL
        tail->next = NULL;
    }
}
 
//display() will print out the nodes of 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()
{
    //Add nodes to the list
    addNode(1);
    addNode(2);
    addNode(3);
    addNode(4);
    addNode(5);
    
    printf("Original List: \n");
    display();
    
    //Rotates list by 3 nodes
    rotateList(3);
    
    printf("Updated List: \n");
    display();
 
    return 0;
}

输出:

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

JAVA

public class RotateList {
    
    //Represent a node of the doubly linked list

    class Node{
        int data;
        Node previous;
        Node next;
        
        public Node(int data) {
            this.data = data;
        }
    }
    
    int size = 0;
    //Represent the head and tail of the doubly linked list
    Node head, tail = null;
    
    //addNode() will add a node to the list
    public void addNode(int data) {
        //Create a new node
        Node newNode = new Node(data);
        
        //If list is empty
        if(head == null) {
            //Both head and tail will point to newNode
            head = tail = newNode;
            //head's previous will point to null
            head.previous = null;
            //tail's next will point to null, as it is the last node of the list
            tail.next = null;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            tail.next = newNode;
            //newNode's previous will point to tail
            newNode.previous = tail;
            //newNode will become new tail
            tail = newNode;
            //As it is last node, tail's next will point to null
            tail.next = null;
        }
        //Size will count the number of nodes present in the list
        size++;
    }
    
    //rotateList() will rotate the list by given n nodes
    public void rotateList(int n) {
        //Initially, current will point to head
        Node current = head;
        
        //n should not be 0 or greater than or equal to number of nodes present in the list
        if(n == 0 || n >= size) 
            return;
        else {
            //Traverse through the list till current point to nth node
            //after this loop, current will point to nth node
            for(int i = 1; i < n; i++) 
                current = current.next;
            
            //Now to move entire list from head to nth node and add it after tail
            tail.next = head;
            //Node next to nth node will be new head
            head = current.next;
            //Previous node to head should be null
            head.previous = null;
            //nth node will become new tail of the list
            tail = current;
            //tail's next will point to null
            tail.next = null;
        }
    }
    
    //display() will print out the nodes of 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 the pointer.

            System.out.print(current.data + " ");
            current = current.next;
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        
        RotateList dList = new RotateList();
        //Add nodes to the list
        dList.addNode(1);
        dList.addNode(2);
        dList.addNode(3);
        dList.addNode(4);
        dList.addNode(5);
        
        System.out.println("Original List: ");
        dList.display();
        
        //Rotates list by 3 nodes
        dList.rotateList(3);
        
        System.out.println("Updated List: ");
        dList.display();
    }
}

输出:

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

C#

using System; 
namespace DoublyLinkedList 
{                     
    public class Program
    {
        //Represent a node of the doubly linked list

        public class Node{
            public T data;
            public Node previous;
            public Node next;
            
            public Node(T value) {
                data = value;
            }
        }
        
        public class RotateList{
            int size = 0;
            //Represent the head and tail of the doubly linked list
            protected Node head = null;             
             protected Node tail = null;
            
            //addNode() will add a node to the list
            public void addNode(T data) {
                //Create a new node
                Node newNode = new Node(data);
 
                //If list is empty
                if(head == null) {
                    //Both head and tail will point to newNode
                    head = tail = newNode;
                    //head's previous will point to null
                    head.previous = null;
                    //tail's next will point to null, as it is the last node of the list
                    tail.next = null;
                }
                else {
                    //newNode will be added after tail such that tail's next will point to newNode
                    tail.next = newNode;
                    //newNode's previous will point to tail
                    newNode.previous = tail;
                    //newNode will become new tail
                    tail = newNode;
                    //As it is last node, tail's next will point to null
                    tail.next = null;
                }
                //Size will count the number of nodes present in the list
                size++;
            }
            
            //rotateList() will rotate the list by given n nodes
            public void rotateList(int n) {
                //Initially, current will point to head
                Node current = head;
 
                //n should not be 0 or greater than or equal to number of nodes present in the list
                if(n == 0 || n >= size) 
                    return;
                else {
                    //Traverse through the list till current point to nth node
                    //after this loop, current will point to nth node
                    for(int i = 1; i < n; i++) 
                        current = current.next;
 
                    //Now to move entire list from head to nth node and add it after tail
                    tail.next = head;
                    //Node next to nth node will be new head
                    head = current.next;
                    //Previous node to head should be null
                    head.previous = null;
                    //nth node will become new tail of the list
                    tail = current;
                    //tail's next will point to null
                    tail.next = null;
                }
            }
    
            //display() will print out the nodes of 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 the pointer.

                    Console.Write(current.data + " ");
                    current = current.next;
                }
                Console.WriteLine();
            }
        }
        
        public static void Main()
        {
            RotateList dList = new RotateList();
            //Add nodes to the list
            dList.addNode(1);
            dList.addNode(2);
            dList.addNode(3);
            dList.addNode(4);
            dList.addNode(5);
 
            Console.WriteLine("Original List: ");
            dList.display();
 
            //Rotates list by 3 nodes
            dList.rotateList(3);
 
            Console.WriteLine("Updated List: ");
            dList.display();
        }    
    }
}

输出:

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

PHP:




data = $data;
    }
}
class RotateList{
    //Represent the head and tail of the doubly linked list
    public $head;
    public $tail;
    public $size = 0;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
        $this->size = 0;
    }
    
    //addNode() will add a node to the list
    function addNode($data){
        //Create a new node
        $newNode = new Node($data);
        
        //If list is empty
        if($this->head == NULL) {
            //Both head and tail will point to newNode
            $this->head = $this->tail = $newNode;
            //head's previous will point to NULL
            $this->head->previous = NULL;
            //tail's next will point to NULL, as it is the last node of the list
            $this->tail->next = NULL;
        }
        else {
            //newNode will be added after tail such that tail's next will point to newNode
            $this->tail->next = $newNode;
            //newNode's previous will point to tail
            $newNode->previous = $this->tail;
            //newNode will become new tail
            $this->tail = $newNode;
            //As it is last node, tail's next will point to NULL
            $this->tail->next = NULL;
        }
        //Size will count the number of nodes present in the list
        $this->size++;
    }
    
    //rotateList() will rotate the list by given n nodes
    function rotateList($n) {
        //Initially, current will point to head
        $current = $this->head;
        
        //n should not be 0 or greater than or equal to number of nodes present in the list
        if($n == 0 || $n >= $this->size) 
            return;
        else {
            //Traverse through the list till current point to nth node
            //after this loop, current will point to nth node
            for($i = 1; $i < $n; $i++) 
                $current = $current->next;
            
            //Now to move entire list from head to nth node and add it after tail
            $this->tail->next = $this->head;
            //Node next to nth node will be new head
            $this->head = $current->next;
            //Previous node to head should be NULL
            $this->head->previous = NULL;
            //nth node will become new tail of the list
            $this->tail = $current;
            //tail's next will point to NULL
            $this->tail->next = NULL;
        }
    }
    
    //display() will print out the nodes of 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("
"); } } $dList = new RotateList(); //Add nodes to the list $dList->addNode(1); $dList->addNode(2); $dList->addNode(3); $dList->addNode(4); $dList->addNode(5); print("Original List:
"); $dList->display(); //Rotates list by 3 nodes $dList->rotateList(3); print("Updated List:
"); $dList->display(); ?>

输出:

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