数据结构示例-单向链表交换节点但不交换数据

📌 相关文章

📜 数据结构示例-单向链表交换节点但不交换数据

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

程序在不交换数据的情况下交换单链列表中的节点

说明

在此程序中，我们需要交换单链表中的给定两个节点而不交换数据。

完成此任务的方法之一是交换给定两个节点中的前一个节点，然后交换两个节点中的下一个节点。

算法

创建一个具有两个属性的类Node：data和next。下一个是指向列表中下一个节点的指针。
创建另一个具有两个属性的类SwapNodes：head和tail。
addNode()将向列表添加一个新节点：
1. 创建一个新节点。
2. 它首先检查head是否等于null，这意味着列表为空。
3. 如果列表为空，则头和尾都将指向新添加的节点。
4. 如果列表不为空，则新节点将被添加到列表的末尾，使得尾部的下一个将指向新添加的节点。这个新节点将成为列表的新尾部。
swap()将交换列表中存在的给定两个节点：
1. 令n1和n2为需要交换的值。
2. 如果列表为空，则从函数返回。
3. 如果n1和n2相等，则列表中将没有变化。
4. 如果列表不为空，则遍历该列表以搜索n1，这样prevNode1将指向早于node1的节点，而node 1将指向具有值n1的节点。
5. 类似地，通过遍历列表来搜索n2，以使prevNode2指向比node2早的节点，而node2则指向具有值n2的节点。
6. 如果prevNode1指向头，则node2将成为列表的头。同样，如果prevNode2指向头，则node1将成为列表的头。
7. 如果prevNode1或prevNode2没有指向头，则交换节点，以使prevNode1将成为node2的前一个节点，而prevNode2将成为node1的前一个节点。
8. 现在，交换节点1和节点2的下一个节点。
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 SwapNodes:
    #Represent the head and tail of the singly linked list
    def __init__(self):
        self.head = None;
        self.tail = None;
        
    #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;
            
    #swap() will swap the given two nodes
    def swap(self, n1, n2):
        prevNode1 = None;
        prevNode2 = None;
        node1 = self.head;
        node2 = self.head;
        
        #Checks if list is empty
        if(self.head == None):
            return;
            
        #If n1 and n2 are equal, then list will remain the same
        if(n1 == n2):
            return;
            
        #Search for node1
        while(node1 != None and node1.data != n1):
            prevNode1 = node1;
            node1 = node1.next;
            
        #Search for node2
        while(node2 != None and node2.data != n2):
            prevNode2 = node2;
            node2 = node2.next;
            
        if(node1 != None and node2 != None):
            
            #If previous node to node1 is not None then, it will point to node2
            if(prevNode1 != None):
                prevNode1.next = node2;
            else:
                self.head  = node2;
                
            #If previous node to node2 is not None then, it will point to node1
            if(prevNode2 != None):
                prevNode2.next = node1;
            else:
                self.head  = node1;
                
            #Swaps the next nodes of node1 and node2
            temp = node1.next; 
            node1.next = node2.next; 
            node2.next = temp;
        else:
            print("Swapping is not possible");
            
    #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 = SwapNodes();
 
#Add nodes to the list
sList.addNode(1);
sList.addNode(2);
sList.addNode(3);
sList.addNode(4);
sList.addNode(5);
 
print("Original list: ");
sList.display();
 
 
#Swaps the node 2 with node 5
sList.swap(2,5);
 
print("List after swapping nodes: ");
sList.display();

输出：

Original list: 
1 2 3 4 5 
List after swapping nodes: 
1 5 3 4 2

C

#include 
 
//Represent a node of the singly linked list
struct node{
    int data;
    struct node *next;
};    
 
//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;
    }
}
 
//swap() will swap the given two nodes
void swap(int n1, int n2){
    struct node *prevNode1 = NULL, *prevNode2 = NULL, *node1 = head, *node2 = head, *temp = NULL;
    
    //Checks if list is empty
    if(head == NULL) {
        return;
    }
        
    //If n1 and n2 are equal, then list will remain the same
    if(n1 == n2)
        return;
    
    //Search for node1
    while(node1 != NULL && node1->data != n1){
        prevNode1 = node1;
        node1 = node1->next;
    }
    
    //Search for node2
    while(node2 != NULL && node2->data != n2){
        prevNode2 = node2;
        node2 = node2->next;
    }
    
    if(node1 != NULL && node2 != NULL) {
        
        //If previous node to node1 is not null then, it will point to node2
        if(prevNode1 != NULL)
            prevNode1->next = node2;        
        else
            head  = node2;
        
        //If previous node to node2 is not null then, it will point to node1
        if(prevNode2 != NULL)
            prevNode2->next = node1;
        else
            head  = node1;
        
        //Swaps the next nodes of node1 and node2
        temp = node1->next; 
        node1->next = node2->next; 
        node2->next = temp;     
    }    
    else{
        printf("Swapping is not possible\n");
    }
}
    
//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()
{
    //Add nodes to the list
    addNode(1);
    addNode(2);
    addNode(3);
    addNode(4);
    addNode(5);
    
    printf("Original list: \n");
    display();
    
    //Swaps the node 2 with node 5
    swap(2,5);
    
    printf("List after swapping nodes: \n");
    display();
 
    return 0;
}

输出：

Original list: 
1 2 3 4 5 
List after swapping nodes: 
1 5 3 4 2

JAVA

public class SwapNodes {
    
    //Represent a node of the singly linked list
    class Node{
        int data;
        Node next;
        
        public Node(int data) {
            this.data = data;
            this.next = null;
        }
    }
 
    //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;
        }
    }
    
    //swap() will swap the given two nodes
    public void swap(int n1, int n2){
        Node prevNode1 = null, prevNode2 = null, node1 = head, node2 = head;
        
        //Checks if list is empty
        if(head == null) {
            return;
        }
        
        //If n1 and n2 are equal, then list will remain the same
        if(n1 == n2)
            return;
        
        //Search for node1
        while(node1 != null && node1.data != n1){
            prevNode1 = node1;
            node1 = node1.next;
        }
        
        //Search for node2
        while(node2 != null && node2.data != n2){
            prevNode2 = node2;
            node2 = node2.next;
        }
        
        if(node1 != null && node2 != null) {
            
            //If previous node to node1 is not null then, it will point to node2
            if(prevNode1 != null)
                prevNode1.next = node2;        
            else
                head  = node2;
            
            //If previous node to node2 is not null then, it will point to node1
            if(prevNode2 != null)
                prevNode2.next = node1;
            else
                head  = node1;
            
            //Swaps the next nodes of node1 and node2
            Node temp = node1.next; 
            node1.next = node2.next; 
            node2.next = temp;     
        }    
        else {
            System.out.println("Swapping is not possible");
        }
    }
    
    //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) {
        
        SwapNodes sList = new SwapNodes();
        
        //Add nodes to the list
        sList.addNode(1);
        sList.addNode(2);
        sList.addNode(3);
        sList.addNode(4);
        sList.addNode(5);
        
        System.out.println("Original list: ");
        sList.display();
        
        //Swaps the node 2 with node 5
        sList.swap(2,5);
        
        System.out.println("List after swapping nodes: ");
        sList.display();
    }
}

输出：

Original list: 
1 2 3 4 5 
List after swapping nodes: 
1 5 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 SwapNodes{
        //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;
            }
        }
        
        //swap() will swap the given two nodes
        public void swap(int n1, int n2){
            Node prevNode1 = null, prevNode2 = null, node1 = head, node2 = head;
 
            //Checks if list is empty
            if(head == null) {
                return;
            }
 
            //If n1 and n2 are equal, then list will remain the same
            if(n1 == n2)
                return;
 
            //Search for node1
            while(node1 != null && !(node1.data.Equals(n1))){
                prevNode1 = node1;
                node1 = node1.next;
            }
 
            //Search for node2
            while(node2 != null && !(node2.data.Equals(n2))){
                prevNode2 = node2;
                node2 = node2.next;
            }
 
            if(node1 != null && node2 != null) {
 
                //If previous node to node1 is not null then, it will point to node2
                if(prevNode1 != null)
                    prevNode1.next = node2;        
                else
                    head  = node2;
 
                //If previous node to node2 is not null then, it will point to node1
                if(prevNode2 != null)
                    prevNode2.next = node1;
                else
                    head  = node1;
 
                //Swaps the next nodes of node1 and node2
                Node temp = node1.next; 
                node1.next = node2.next; 
                node2.next = temp;     
            }    
            else {
                Console.WriteLine("Swapping is not possible");
            }
        }
        
        //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()
    {
        SwapNodes sList = new SwapNodes();
        
        //Add nodes to the list
        sList.addNode(1);
        sList.addNode(2);
        sList.addNode(3);
        sList.addNode(4);
        sList.addNode(5);
        
        Console.WriteLine("Original list: ");
        sList.display();
        
        //Swaps the node 2 with node 5
        sList.swap(2,5);
        
        Console.WriteLine("List after swapping nodes: ");
        sList.display();    
    }
}

输出：

Original list: 
1 2 3 4 5 
List after swapping nodes: 
1 5 3 4 2

PHP：




data = $data;
        $this->next = NULL;
    }
}
class SwapNodes{
    //Represent the head and tail of the singly linked list
    public $head;
    public $tail;
    function __construct(){
        $this->head = NULL;
        $this->tail = NULL;
    }
    
    //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;
        }
    }
    
    //swap() will swap the given two nodes
    function swap($n1, $n2){
        $prevNode1 = null;
        $prevNode2 = null;
        $node1 = $this->head;
        $node2 = $this->head;
        
        //Checks if list is empty
        if($this->head == null) {
            return;
        }
        
        //If n1 and n2 are equal, then list will remain the same
        if($n1 == $n2)
            return;
        
        //Search for node1
        while($node1 != null && $node1->data != $n1){
            $prevNode1 = $node1;
            $node1 = $node1->next;
        }
        
        //Search for node2
        while($node2 != null && $node2->data != $n2){
            $prevNode2 = $node2;
            $node2 = $node2->next;
        }
        
        if($node1 != null && $node2 != null) {
            
            //If previous node to node1 is not null then, it will point to node2
            if($prevNode1 != null)
                $prevNode1->next = $node2;        
            else
                $this->head  = $node2;
            
            //If previous node to node2 is not null then, it will point to node1
            if($prevNode2 != null)
                $prevNode2->next = $node1;
            else
                $this->head  = $node1;
            
            //Swaps the next nodes of node1 and node2
            $temp = $node1->next; 
            $node1->next = $node2->next; 
            $node2->next = $temp;     
        }    
        else {
            print("Swapping is not possible 
");
        }
    }
    
    //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 SwapNodes();
        
//Add nodes to the list
$sList->addNode(1);
$sList->addNode(2);
$sList->addNode(3);
$sList->addNode(4);
$sList->addNode(5);
 
print("Original list: 
");
$sList->display();
 
//Swaps the node 2 with node 5
$sList->swap(2,5);
 
print("List after swapping nodes: 
");
$sList->display();
?>

输出：

Original list: 
1 2 3 4 5 
List after swapping nodes: 
1 5 3 4 2