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

最新推荐文章于 2023-05-20 22:39:17 发布
最新推荐文章于 2023-05-20 22:39:17 发布
阅读量767 收藏 2
点赞数
文章标签： java单链表交换相邻元素
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36312603/article/details/114622323
版权
这篇博客介绍如何在单向链表中交换相邻两个元素。提供了C、Java和C#三种语言的代码实现，交换是通过改变链域（指针域）而非数据域完成的，以避免在数据字段多时造成不必要的交换操作。时间复杂度为O(n)，适用于不同长度的链表，包括奇数和偶数个节点的情况。
摘要由CSDN通过智能技术生成

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

输入: 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#include

/*A linked list node*/

structNode {intindex;intdata;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,intnew_data)

{//allocate node

struct Node* new_node = (struct Node*)malloc(sizeof(structNode));//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*/

intmain() {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;

}

a8b743f249431e982173163d8f42358f.png

java代码：

//Java program to swap elements of linked list by changing links

classLinkedList {staticNode head;static classNode {intdata;

Node next;

Node(intd)

{

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) {returnnode;

}//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;

}returnnode;

}/*Function to print nodes in a given linked list*/

voidprintList(Node node)

{while (node != null) {

System.out.print(node.data+ " ");

node=node.next;

}

}//Driver program to test above functions

public static voidmain(String[] args)

{/*The constructed linked list is:

1->2->3->4->5->6->7*/LinkedList list= newLinkedList();

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

usingSystem;public classLinkedList {

Node head;public classNode {public intdata;publicNode next;public Node(intd)

{

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) {returnnode;

}//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;

}returnnode;

}/*Function to print nodes

in a given linked list*/

voidprintList(Node node)

{while (node != null) {

Console.Write(node.data+ " ");

node=node.next;

}

}//Driver code

public static voidMain(String[] args)

{/*The constructed linked list is:

1->2->3->4->5->6->7*/LinkedList list= newLinkedList();

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#include

/*A linked list node*/

structNode

{intdata;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)returnhead;//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

returnnewhead;

}/*function to add a node at the begining of Linked List*/

void push(struct Node** head_ref, intnew_data)

{//allocate node

struct Node* new_node = (struct Node*)malloc(sizeof(structNode));//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*/

intmain()

{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;

}

结果：

bbfed960e49749fb70c12b441eb45a24.png

java代码：

//Java program to swap elements of linked list by changing links

classLinkedList {staticNode head;static classNode {intdata;

Node next;

Node(intd)

{

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) {returnnode;

}//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

returnnewhead;

}/*Function to print nodes in a given linked list*/

voidprintList(Node node)

{while (node != null) {

System.out.print(node.data+ " ");

node=node.next;

}

}//Driver program to test above functions

public static voidmain(String[] args)

{/*The constructed linked list is:

1->2->3->4->5->6->7*/LinkedList list= newLinkedList();

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

usingSystem;public classLinkedList {

Node head;classNode {public intdata;publicNode next;public Node(intd)

{

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) {returnnode;

}//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

returnnewhead;

}/*Function to print nodes in a given linked list*/

voidprintList(Node node)

{while (node != null) {

Console.Write(node.data+ " ");

node=node.next;

}

}//Driver program to test above functions

public static voidMain()

{/*The constructed linked list is:

1->2->3->4->5->6->7*/LinkedList list= newLinkedList();

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

其他参考:

717542177
关注
java单链表交换相邻元素_数据结构:单向链表系列6--交换相邻两个节点1（交换数据域）...
weixin_35317737的博客
02-25 1350
给定一个单向链表,编写函数交换相邻 两个元素输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7输出: 2 -> 1 -> 4 -> 3 -> 6 -> 5 -> 7输入: 1 -> 2 -> 3 -> 4 -> 5 -> 6输出: 2 -> 1 -> 4 ->...
java单链表交换相邻元素_1.7交换链表中的相邻节点
weixin_39673972的博客
02-25 645
交换链表中的相邻节点题目描述：把链表相邻元素翻转，例如给定链表为1——＞2一＞3一>4一＞5——>6一＞7，则翻转后的链表变为2一＞1一＞4一＞3一＞6一＞5一＞7解题思路：就地逆序法：通过调整结点指针域的指向来直接调换相邻的两个结点。如果单链表恰好有偶数个结点，那么只需要将奇偶结点对调即可，如果链表有奇数个结点，那么只需要将除最后一个结点外的其它结点进行奇偶对调即可。代码实现：# -...
Java单链表中的元素互换位置_java实现单链表及倒置单链表中的元素
weixin_34609222的博客
02-24 554
单链表的结构比较简单，图示如下： 单链表有很多个节点构成。每个节点由指针域和数值域构成，指针指向下一个节点的数值域。最后一个节点的指针指向的是NULL。 java实现单链表的一些基本的操作： package test;import javax.xml.soap.Node;/** * 单链表的创要实现单链表，首先要建立链表的节点类：单链表在插入和删除操作时，有无头结点的实现是有区别的，总的来说，带有...
java单链表交换相邻元素_单链表的基本操作---插入，删除，交，并，相邻元素的交换等...
weixin_30698949的博客
02-13 621
//引用头文件#include "list.h"#include#include"fatal.h"//结构体定义structNode{ElementType Element;Position Next;};//初始化链表List MakeEmpty(List L){if (L !=NULL)DeleteList(L);//如果链表非空，则删除链表L = malloc(sizeof(structNo...
java单链表交换相邻元素_链表--链表中相邻元素两两交换（leetcode24
weixin_35700003的博客
02-25 512
递归解法递归写法要观察本级递归的解决过程，形成抽象模型，因为递归本质就是不断重复相同的事情。而不是去思考完整的调用栈，一级又一级，无从下手，应该关注一级调用小单元的情况，也就是单个f(x)。其中我们应该关心的主要有三点：返回值调用单元做了什么终止条件要注意终止条件：head为空(没有结点了)或者head.next为空(只剩一个结点了，不用再换了)head是函数传进来的参数，head随着递归的过程中...
graph_DFS.zip_C语言单向链表_linux 链表_链表_链表 linux
09-24
例如，每个节点可以是一个结构体，包含数据和一个指向相邻节点的指针。在链表中实现DFS通常涉及递归调用，这在给定的压缩包文件中可能被命名为“graph_DFS”部分。 DFS在图处理中广泛应用，例如解决连通性问题、...
链表-使用PHP实现的双向链表数据结构.zip
03-13
这使得在链表中插入和删除元素相比数组更加高效，因为只需要改变相邻节点的指针即可，而无需移动大量内存。 在本案例中，"链表-使用PHP实现的双向链表数据结构.zip" 是一个压缩文件，其中包含了一个使用PHP语言实现...
c++数据结构—单向链表
qq_67972375的博客
03-14 1855
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
【数据结构】单链表详解-无头单向不循环链表
p2141548684的博客
05-20 433
链表是一种物理存储上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。单链表、双链表和循环链表。单向、双向、带头、不带头、循环、不循环。链表的八种带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、无头单向循环链表、无头单向非循环链表、无头双向循环链表、无头双向非循环链表。
数据结构学习--线性表及其应用--链表
06-25
单向链表是最简单的链表形式，每个节点包含一个数据域和一个指向下一个节点的指针。在本程序中，数据域被定义为字符串类型，这样可以存储各种文本信息。链表的头节点是一个特殊的节点，其指针域指向链表的第一个实际...
Java算法——7把链表相邻元素翻转（交换值法、就地逆序）
weixin_44704538的博客
12-18 658
文章目录题目描述方法一：交换值法方法二：就地逆序算法性能分析 题目描述 把链表相邻元素翻转，如给定链表为1→2→3→4→5→6→7，则翻转后的链表为2→1→4→3→6→5→7 方法一：交换值法 最容易想到的方法就是交换相邻两个结点的数据域，这种方法由于不需要重新调整链表的结构，因此比较容易实现，但是这种方法并不是考官所期望的解法 方法二：就地逆序 主要思路：通过调整结点指针域的指向来直接调换相邻的两个结点。如果单链表恰好有偶数个结点，那么只需要将奇偶结点对调即可，如果链表有奇数个结点，那么只需要将除了最后一
JAVA单向链表指定元素交换_java对单向单向链表的操作
weixin_35897916的博客
02-25 245
概述：众所周知，数据对于数据的存储时连续的，也就是说在计算机的内存中是一个整体的、连续的、不间断的ADT数据结构。伴随的问题也会随之出现，这样其实对于内存的动态分配是不灵活的。而链表具备这个优点。因此链表对于数据的插入和删除是方便的，但是对于数据的查询是麻烦的。因为需要遍历链表，而对于链表的遍历确实极度的麻烦。1 单向链表的定义链表主要用来存储引用类型的数据。其结构可以由下图清楚的表示：链表结点的...
数据结构-单链表交换相邻两个元素-java
筱筱_之家的博客
12-02 977
1.递归法：时间复杂度O /* 原理：对每一个结点进行反转 */ public ListNode reverseList(ListNode head) { if(head == null || head.next == null){ return head; } ListNode curr = reverseList(head.next); head.next.next = head; head
java链表节点置换_Java实现双链表互相交换任意两个节点的方法示例
weixin_39839726的博客
02-17 553
我们在学习C++的时候都曾使用过链表这个功能，而在Java中要如何实现双链表互相交换的节点呢？这需要结合不同的操作技巧，别着急，爱站技术频道为大家带来Java实现双链表互相交换任意两个节点的方法示例，希望能帮到您。概述：双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我...
两两交换链表中的节点(Java)
LRC1062702315的博客
04-06 928
（leetcode 24） 题目要求 给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。 思路 每次判断后，temp节点后移两位。 代码 public ListNode swapPairs(ListNode head) { ListNode newHead = new ListNode(-1); newHead.next = head; ListNode
链表交换相邻节点
我的博客
04-25 2970
leetcode 24. Swap Nodes in Pairs方法一：用指针的指针的方法(leetcode大神思路很巧妙)/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), nex...
LeetCode初级算法之链表:链表交换相邻元素
Miracle8070
01-28 1033
好久没有刷题了，之前都是使用C++刷题的，现在发现Python用的多，并且对于Python的语法掌握的并不熟练，所以逼着自己通过刷题掌握Python，所以后期的刷题全都使用Python语言，语言是次要的。 下面的题目： 链表交换相邻元素 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例: 给定 1->2-&gt...
链表：调换相邻元素
Peanut 大本营
03-10 1707
    给定一个链表，把相邻的两个元素进行互换。    如给定链表1->2->3->4->5->6，则互换后的结果为2->1->4->3->6->5。 public ListNode swapPairs(ListNode head) { if(head == null || head.next == null) ...
Java——两两交换链表中的节点
m0_60867520的博客
01-31 613
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
通过只调整链(而不是数据)来交换两个相邻的元素，分别使用a)单 链表；b)双向表链。 用C++实现
最新发布
09-21
在链表结构中，由于链表节点之间没有直接的指针连接，我们无法像数组那样简单地交换两个相邻元素。但是，我们可以使用迭代或者递归的方式来间接交换。这里给出的是使用单链表和双向链表的C++实现： **a) 单向链表 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值