• 数据结构:单向链表系列7--交换相邻两个节点2(交换链域/指针域)


    给定一个单向链表,编写函数交换相邻 两个元素

    输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7

    输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7

    输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6

    输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5

    通过观察发现:当输入的与元素个数是单数的时候,最后一位不参与交换。 

    当链表节点中的数据字段不多的时候我们可以交换数据域的指针来实现相邻两个节点的交换

    当数据域太多时操作成本将非常昂贵,该情形下,更改链域(指针域)将是一个更好的解决方法。

    以下是代码的实现:

    时间复杂度:O(n)

    c语言:

    /* 
     the program swaps the nodes of linked list rather than swapping the
     field from the nodes.
     Imagine a case where a node contains many fields, there will be plenty
     of unnecessary swap calls.
    */
    #include <stdio.h>
    #include <stdlib.h>
    
    /* A linked list node*/
    struct Node {    
        int index;
        int data;
        struct Node* next;
    };
    
    
    /* function to pairwise swap elements of a linked list */
    void pairWiseSwap(struct Node** head_ref)
    {
        //if linked list empty or there is only one node in list
        if(*head_ref == NULL || (*head_ref)->next == NULL)
        {
            return;
        }
    
        //initialize previous and current pointers
        struct Node* previous = *head_ref;
        struct Node* current = (*head_ref)->next;
    
        //change head before proceeding    
        *head_ref = current;
    
        //Traverse the list    
        while(1)
        {
            struct Node* next = current->next;
            
            //change next of current as previous node
            current->next = previous;
    
            //if next NULL or next is last node
            if(next == NULL || next->next == NULL)
            {
                previous->next = next;
                break;
            }
    
            //change next of previous to next next
            previous->next = next->next;
    
            //update previous and current
            previous = next;
            current = previous->next;
        }
    }
    
    
    /* function to add a node at the beginning of Linked List */
    void push(struct Node** head_ref, int index,int new_data)
    {
        //allocate node
        struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    
        //fill with the index
        new_node->index = index;
    
        //put in the data
        new_node->data = new_data;
    
        //link the old list of the new node
        new_node->next = (*head_ref);
    
        //move the head to point to the new node
        (*head_ref) = new_node;
    }
    
    /* function to print nodes in a given linked list */
    void printList(struct Node* node)
    {
        while(node != NULL)
        {
            printf("(index %d)%d ", node->index, node->data);
            node = node->next;
        }
        printf("
    ");
    }
    
    /*driver program to test above function*/
    int main() {
    
        struct Node* start = NULL;
        /*
            the constructed linked list is:
            1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7
         */
        push(&start, 7, 7);
        push(&start, 6, 6);
        push(&start ,5, 5);
        push(&start, 4, 4);
        push(&start, 3, 3);
        push(&start, 2, 2);
        push(&start, 1, 1);
    
        printf("Linked list before calling pairwise swap function
    ");
    
        printList(start);
    
        pairWiseSwap(&start);
    
        printf("Linked list after calling pairwise swap function
    ");
    
        printList(start);
        return 0;
    }

     java代码:

    // Java program to swap elements of linked list by changing links 
      
    class LinkedList { 
      
        static Node head; 
      
        static class Node { 
      
            int data; 
            Node next; 
      
            Node(int d) 
            { 
                data = d; 
                next = null; 
            } 
        } 
      
        /* Function to pairwise swap elements of a linked list */
        Node pairWiseSwap(Node node) 
        { 
      
            // If linked list is empty or there is only one node in list 
            if (node == null || node.next == null) { 
                return node; 
            } 
      
            // Initialize previous and current pointers 
            Node prev = node; 
            Node curr = node.next; 
      
            node = curr; // Change head before proceeeding 
      
            // Traverse the list 
            while (true) { 
                Node next = curr.next; 
                curr.next = prev; // Change next of current as previous node 
      
                // If next NULL or next is the last node 
                if (next == null || next.next == null) { 
                    prev.next = next; 
                    break; 
                } 
      
                // Change next of previous to next next 
                prev.next = next.next; 
      
                // Update previous and curr 
                prev = next; 
                curr = prev.next; 
            } 
            return node; 
        } 
      
        /* Function to print nodes in a given linked list */
        void printList(Node node) 
        { 
            while (node != null) { 
                System.out.print(node.data + " "); 
                node = node.next; 
            } 
        } 
      
        // Driver program to test above functions 
        public static void main(String[] args) 
        { 
      
            /* The constructed linked list is: 
             1->2->3->4->5->6->7 */
            LinkedList list = new LinkedList(); 
            list.head = new Node(1); 
            list.head.next = new Node(2); 
            list.head.next.next = new Node(3); 
            list.head.next.next.next = new Node(4); 
            list.head.next.next.next.next = new Node(5); 
            list.head.next.next.next.next.next = new Node(6); 
            list.head.next.next.next.next.next.next = new Node(7); 
      
            System.out.println("Linked list before calling pairwiseSwap() "); 
            list.printList(head); 
            Node st = list.pairWiseSwap(head); 
            System.out.println(""); 
            System.out.println("Linked list after calling pairwiseSwap() "); 
            list.printList(st); 
            System.out.println(""); 
        } 
    } 
      
    // This code has been contributed by Mayank Jaiswal 

    c#代码:

    // C# program to swap elements of 
    // linked list by changing links 
    using System; 
      
    public class LinkedList { 
      
        Node head; 
      
        public class Node { 
      
            public int data; 
            public Node next; 
      
            public Node(int d) 
            { 
                data = d; 
                next = null; 
            } 
        } 
      
        /* Function to pairwise swap  
        elements of a linked list */
        Node pairWiseSwap(Node node) 
        { 
      
            // If linked list is empty or there 
            // is only one node in list 
            if (node == null || node.next == null) { 
                return node; 
            } 
      
            // Initialize previous and current pointers 
            Node prev = node; 
            Node curr = node.next; 
      
            // Change head before proceeeding 
            node = curr; 
      
            // Traverse the list 
            while (true) { 
                Node next = curr.next; 
      
                // Change next of current as previous node 
                curr.next = prev; 
      
                // If next NULL or next is the last node 
                if (next == null || next.next == null) { 
                    prev.next = next; 
                    break; 
                } 
      
                // Change next of previous to next next 
                prev.next = next.next; 
      
                // Update previous and curr 
                prev = next; 
                curr = prev.next; 
            } 
            return node; 
        } 
      
        /* Function to print nodes  
        in a given linked list */
        void printList(Node node) 
        { 
            while (node != null) { 
                Console.Write(node.data + " "); 
                node = node.next; 
            } 
        } 
      
        // Driver code 
        public static void Main(String[] args) 
        { 
      
            /* The constructed linked list is:  
            1->2->3->4->5->6->7 */
            LinkedList list = new LinkedList(); 
            list.head = new Node(1); 
            list.head.next = new Node(2); 
            list.head.next.next = new Node(3); 
            list.head.next.next.next = new Node(4); 
            list.head.next.next.next.next = new Node(5); 
            list.head.next.next.next.next.next = new Node(6); 
            list.head.next.next.next.next.next.next = new Node(7); 
      
            Console.WriteLine("Linked list before calling pairwiseSwap() "); 
            list.printList(list.head); 
            Node st = list.pairWiseSwap(list.head); 
            Console.WriteLine(""); 
            Console.WriteLine("Linked list after calling pairwiseSwap() "); 
            list.printList(st); 
            Console.WriteLine(""); 
        } 
    } 
      
    // This code contributed by Rajput-Ji 

    递归法:

    c语言:

    /*
        This program swaps the nodes of linkd list rather than swapping the
        field from the nodes.
        Imagine a case where a node contains many fields, there will be plenty
        of unnecessary swap calls
    */
    
    #include <stdio.h>
    #include <stdlib.h>
     
     /* A linked list node */
    struct Node
    {
        int data;
        struct Node* next;    
    };
    
    /* function to pairwise swap elements of a linked list.
       it returns head of the modified list, so return value
       of this node must be assigned
    */
    struct Node* pairWiseSwap(struct Node* head)
    {
        //base case: the list is empty or has only one node
        if(head == NULL || head->next == NULL)
            return head;
    
        //store head of list after two nodes
        struct Node* remaing = head->next->next;
    
        //chnage head
        struct Node* newhead = head->next;
    
        //change next of second node
        head->next->next = head;
    
        //recursive for remaining list and change next of head
        head->next = pairWiseSwap(remaing);
    
        //Return new head of modified list
        return newhead;
    }
    
    /* function to add a node at the begining of Linked List */
    void push(struct Node** head_ref, int new_data)
    {
        //allocate node
        struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    
        //puth in the data
        new_node->data = new_data;
    
        /* link the old list off the new node */
        new_node->next = (*head_ref);
    
        /* move the head to point to the new node */
        (*head_ref) = new_node;    
    }
    
    /* function to print nodes in a given linked list */
    void printList(struct Node* node)
    {
        while( node != NULL )
        {
            printf("%d ", node->data);
            node = node->next;
        }
        printf("
    ");
    }
    
    /* Driver program to test above function */
    int main()
    {
        struct Node* start = NULL;
    
        /* the constructed linked list is
            1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7
         */
        
        push(&start, 7);
        push(&start, 6);
        push(&start, 5);
        push(&start, 4);
        push(&start, 3);
        push(&start, 2);
        push(&start, 1);
    
    
        printf("Linked List before calling pairWiseSwap function
    ");
        printList(start);
    
        // note this change
        start = pairWiseSwap(start);
        printf("Linked list after calling pairWiseSwap function
    ");
        printList(start);
    
        return 0;
    }

    结果:

     java代码:

    // Java program to swap elements of linked list by changing links 
    
    class LinkedList { 
    
        static Node head; 
    
        static class Node { 
    
            int data; 
            Node next; 
    
            Node(int d) 
            { 
                data = d; 
                next = null; 
            } 
        } 
    
        /* Function to pairwise swap elements of a linked list. 
        It returns head of the modified list, so return value 
        of this node must be assigned */
        Node pairWiseSwap(Node node) 
        { 
    
            // Base Case: The list is empty or has only one node 
            if (node == null || node.next == null) { 
                return node; 
            } 
    
            // Store head of list after two nodes 
            Node remaing = node.next.next; 
    
            // Change head 
            Node newhead = node.next; 
    
            // Change next of second node 
            node.next.next = node; 
    
            // Recur for remaining list and change next of head 
            node.next = pairWiseSwap(remaing); 
    
            // Return new head of modified list 
            return newhead; 
        } 
    
        /* Function to print nodes in a given linked list */
        void printList(Node node) 
        { 
            while (node != null) { 
                System.out.print(node.data + " "); 
                node = node.next; 
            } 
        } 
    
        // Driver program to test above functions 
        public static void main(String[] args) 
        { 
    
            /* The constructed linked list is: 
            1->2->3->4->5->6->7 */
            LinkedList list = new LinkedList(); 
            list.head = new Node(1); 
            list.head.next = new Node(2); 
            list.head.next.next = new Node(3); 
            list.head.next.next.next = new Node(4); 
            list.head.next.next.next.next = new Node(5); 
            list.head.next.next.next.next.next = new Node(6); 
            list.head.next.next.next.next.next.next = new Node(7); 
    
            System.out.println("Linked list before calling pairwiseSwap() "); 
            list.printList(head); 
            head = list.pairWiseSwap(head); 
            System.out.println(""); 
            System.out.println("Linked list after calling pairwiseSwap() "); 
            list.printList(head); 
            System.out.println(""); 
        } 
    } 

    c#

    // C# program to swap elements 
    // of linked list by changing links 
    using System; 
    
    public class LinkedList { 
        Node head; 
    
        class Node { 
            public int data; 
            public Node next; 
    
            public Node(int d) 
            { 
                data = d; 
                next = null; 
            } 
        } 
    
        /* Function to pairwise swap 
            elements of a linked list. 
            It returns head of the modified 
            list, so return value of this 
            node must be assigned */
        Node pairWiseSwap(Node node) 
        { 
    
            // Base Case: The list is empty 
            // or has only one node 
            if (node == null || node.next == null) { 
                return node; 
            } 
    
            // Store head of list after two nodes 
            Node remaing = node.next.next; 
    
            // Change head 
            Node newhead = node.next; 
    
            // Change next of second node 
            node.next.next = node; 
    
            // Recur for remaining list 
            // and change next of head 
            node.next = pairWiseSwap(remaing); 
    
            // Return new head of modified list 
            return newhead; 
        } 
    
        /* Function to print nodes in a given linked list */
        void printList(Node node) 
        { 
            while (node != null) { 
                Console.Write(node.data + " "); 
                node = node.next; 
            } 
        } 
    
        // Driver program to test above functions 
        public static void Main() 
        { 
    
            /* The constructed linked list is: 
            1->2->3->4->5->6->7 */
            LinkedList list = new LinkedList(); 
            list.head = new Node(1); 
            list.head.next = new Node(2); 
            list.head.next.next = new Node(3); 
            list.head.next.next.next = new Node(4); 
            list.head.next.next.next.next = new Node(5); 
            list.head.next.next.next.next.next = new Node(6); 
            list.head.next.next.next.next.next.next = new Node(7); 
    
            Console.WriteLine("Linked list before calling pairwiseSwap() "); 
            list.printList(list.head); 
            list.head = list.pairWiseSwap(list.head); 
            Console.WriteLine(""); 
            Console.WriteLine("Linked list after calling pairwiseSwap() "); 
            list.printList(list.head); 
            Console.WriteLine(""); 
        } 
    } 
    
    // This code is contributed by PrinciRaj1992 

    来源:https://www.geeksforgeeks.org/pairwise-swap-elements-of-a-given-linked-list-by-changing-links/

    其他参考:

    https://www.geeksforgeeks.org/pairwise-swap-adjacent-nodes-of-a-linked-list-by-changing-pointers-set-2/

  • 相关阅读:
    ubuntu安装pgAdmin 4
    python 读取文件
    byobu copy
    vim快捷键汇总
    python 停止线程
    python执行外部命令并获取输出
    gevent mysql
    python类型转换
    量化交易
    Java集合:HashMap底层实现和原理(源码解析)
  • 原文地址:https://www.cnblogs.com/passedbylove/p/11439541.html
Copyright © 2020-2023  润新知