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

最新推荐文章于 2023-03-14 15:46:37 发布
最新推荐文章于 2023-03-14 15:46:37 发布
阅读量466 收藏
点赞数
文章标签： 数据结构与算法 c/c++ c#
原文链接：http://www.cnblogs.com/passedbylove/p/11439541.html
版权

 

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

输入: 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("\n");
}

/*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\n");

    printList(start);

    pairWiseSwap(&start);

    printf("Linked list after calling pairwise swap function\n");

    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("\n");
}

/* 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\n");
    printList(start);

    // note this change
    start = pairWiseSwap(start);
    printf("Linked list after calling pairWiseSwap function\n");
    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/

转载于:https://www.cnblogs.com/passedbylove/p/11439541.html

weixin_30399155
关注
C：数据结构：单向链表
becky_lyl的博客
05-12 56
单向链表即表的方向为一个，即从头结点处开始，尾结点结束，尾结点的指针域指向NULL，标志着链表的结束。链表的操作有 头插法、尾插法、遍历链表、查询结点、删除结点、指定位置添加结点、移动结点。
数据结构-链表结构-单向链表
qq_44715376的博客
07-31 496
单向链表，链表与数组的区别，自定义单向链表
交换单向链表的相邻节点
谦言万语的专栏
08-13 2163
#include #include //The struct of list node typedef struct Node {  int  iData;  struct Node* pNext; }LNode,*PNode; /**  * Swap the place between two near nodes  */ void nearLNodeSwap(LN
单链表-交换相邻节点 & 反转链表
dinghua_xuexi的专栏
07-14 1021
定义单链表 class MyLinkedList { static class ListNode{ int val; ListNode next; public ListNode(int val,ListNode next){ this.val = val; this.next = next; } } ListNode head,tail; int size
单链表操作——交换节点-dm
weixin_33928467的博客
02-25 808
2019独角兽企业重金招聘Python工程师标准>>> ...
leetcode24（两两交换链表中的节点：递归与迭代
CY2333333的博客
10-15 397
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例： 输入：head = [1,2,3,4] 输出：[2,1,4,3] 题解（一）：递归，每两个节点设为一个子链表，更改子链表方向，同时将子链表尾指针指向下一个两个节点组成的子链表 class Solution { public ListNode swapPairs(ListNode head) { if(head==null||head.next==null
java单链表交换相邻元素_数据结构:单向链表系列6--交换相邻两个节点1（交换数据域）...
weixin_35317737的博客
02-25 1362
给定一个单向链表,编写函数交换相邻 两个元素输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6输出: 2 -> 1 -> 4 ->...
数据结构学习--线性表及其应用--链表
06-25
单向链表是最简单的链表形式，每个节点包含一个数据域和一个指向下一个节点的指针。在本程序中，数据域被定义为字符串类型，这样可以存储各种文本信息。链表的头节点是一个特殊的节点，其指针域指向链表的第一个实际...
链表-使用PHP实现的双向链表数据结构.zip
最新发布
03-13
双向链表是链表的一种变体，与单向链表不同，它允许从两个方向遍历链表。每个节点除了包含数据和指向下一个节点的指针外，还有一个指向前一个节点的指针。这样的设计提高了数据操作的灵活性，例如在链表中间插入或...
c++数据结构—单向链表
qq_67972375的博客
03-14 1907
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
交换单链表相邻的两个节点
坑底Z蛙
04-06 4781
给定一个链表，对每两个相邻的结点作交换并返回头节点。例如：给定 1-&gt;2-&gt;3-&gt;4，你应该返回 2-&gt;1-&gt;4-&gt;3。你的算法应该只使用额外的常数空间。不要修改列表中的值，只有节点本身可以​​更改。# Definition for singly-linked list. class ListNode: def __init__(self, x): ...
Leetcode24--->Swap Nodes in Pairs(交换单链表中相邻的两个节点)
weixin_30633949的博客
09-17 99
题目：给定一个单链表，交换两个相邻的节点，且返回交换之后的头节点 举例： Given1->2->3->4, you should return the list as2->1->4->3. 解题思路： 题目本身很简单，但是要注意一些细节： 1. 两对节点之间的连接 2. 如果只剩下一个节点，则不需要交换 代码如下： 1 /** ...
交换单链表中相邻的两个点(人搜)
yejing's utopia
01-20 671
/************************************************************* * file:reverse_twins_node_of_list.c * brief:交换单链表中相邻的两个点 * yejing@2015.1.20 1.0 creat ***************************************
链表内部交换（交换结点指针域）
weixin_61652444的博客
12-17 1559
void sort(void) { Node* pi = head; while (pi != NULL) { int sum = 0; for (int cnt = 0; cnt < 4; cnt++) { sum += pi->score[cnt]; } pi->total = sum; pi->average = (double)(sum) / 4; pi = pi->next; } Node* headp = (Node*).
将单链表中相邻两节点对换
ok0011的博客
06-11 513
class ListNode { int val; ListNode next; ListNode(int x) { val = x; } }public class Solution { public ListNode swapPairs1(ListNode head) { if (head == null || head.ne
c语言结构交换结点指针域,数据结构学习笔记——线性表之单链表（c语言实现）...
weixin_39524048的博客
05-19 764
1.概念链式存储结构：是指把数据元素存放在任意内存未被占用的存储单元里，这组存储单元可以是连续的，也可以是不连续的。大概就是这样：因此，为了表示每个数据元素a1，与其直接后继数据元素 a2 之间的逻辑关系，对数据元素a来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息(即直接后继的存储位置)。对此有如下几个概念：数据域指针域指针(链)头指针存储数据元素信息的域存储直接后继位置的域指针...
数据结构:单向链表系列6--交换相邻两个节点1（交换数据域）
weixin_30399155的博客
08-31 1318
给定一个单向链表,编写函数交换相邻 两个元素 输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7 输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 输出: 2...
c语言结构交换结点指针域,【数据结构】C语言实现链表节点的插入和删除
weixin_33907300的博客
05-19 359
/*链表节点的插入与删除编译环境：VC++ 6.0编译系统：windows XP SP3*/#include #include #include // 定义链表中的节点typedef struct node{int member; // 节点中的成员struct node *pNext; // 指向下一个节点的指针}Node,*pNod...
C-单链表之相邻结点交换
nnluop的博客
11-21 2206
11.21-本文实现的相邻结点交换- 本文注释均为我在写代码途中遇到的问题 //本文实现单链表的相邻结点交换 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node* next; }Lnode,*Linklist; //使用尾插法建立单链表 Linklist creat() { Linklist L,s; Lnode* p; int e; L=(Linklist)ma
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值