题目
给出一个链表,两两交换链表中的节点,返回结果
说明
输入:1->2->3->4->null
输出:2->1->4->3->null
输入:5->null
输出:5->null
不能只是改变节点内部的值来实现
答案
Node:
package com.leolee.dataStructure.linkedList;
/**
* @ClassName Node
* @Description: 链表节点对象
* @Author LeoLee
* @Date 2020/9/14
* @Version V1.0
**/
public class Node {
public int no;
public String name;
public String nikeName;
public Node next;
public Node (int no, String name, String nikeName) {
this.no = no;
this.name = name;
this.nikeName = nikeName;
}
@Override
public String toString() {
return "Node{" +
"no=" + no +
", name='" + name + '\'' +
", nikeName='" + nikeName + '\'' +
// ", next=" + next +
'}';
}
}
SingleLinkedList(链表):
package com.leolee.dataStructure.linkedList;
import java.util.Stack;
/**
* @ClassName SingleLinkedList
* @Description: TODO
* @Author LeoLee
* @Date 2020/9/14
* @Version V1.0
**/
public class SingleLinkedList {
//初始化头节点
private Node headNode = new Node(0, "", "");
private int size = 0;
//在链表尾部插入节点
public void add (Node newNode) {
Node tempNode = headNode;
//遍历寻找最后的节点
while (true) {
if (tempNode.next == null) {
break;
}
tempNode = tempNode.next;
}
tempNode.next = newNode;
size++;
}
//按照顺序插入
public void addByOrder (Node newNode) {
Node tempNode = headNode;
boolean flag = false;//相同编号的节点是否已经存在
while (true) {
if (tempNode.next == null) {//说明当前节点为链表最后的节点
break;
}
if (tempNode.next.no > newNode.no) {//找到插入位置,在tempNode后面插入
break;
} else if (tempNode.next.no == newNode.no) {//已经存在该节点
flag = true;
break;
}
//以上条件不成立,后移当前节点,下一次循环开始
tempNode = tempNode.next;
}
if (flag) {
System.out.printf("添加的节点编号已经存在%d,不能添加\n", newNode.no);
} else {
newNode.next = tempNode.next;
tempNode.next = newNode;
size++;
}
}
public void update (Node newNode) {
//判断链表是否为空
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
Node tempNode = headNode.next;
boolean flag = false;//是否找到要修改的节点(是否找到no一样的节点)
while (true) {
if (tempNode == null) {//最后一个节点的next为空,遍历结束了
break;
}
if (tempNode.no == newNode.no) {
flag = true;
break;
}
tempNode = tempNode.next;
}
if (flag) {
tempNode.name = newNode.name;
tempNode.nikeName = newNode.nikeName;
} else {
System.out.printf("没有找到对应需要修改的节点[%d]", newNode.no);
}
}
public void delete (int targetNo) {
Node tempNode = headNode;
boolean flag = false;//是否找到需要删除的节点的上一个节点
while (true) {
if (tempNode.next == null) {
System.out.println("没有找到链表中需要删除的目标节点");
break;
}
if (tempNode.next.no == targetNo) {
flag = true;
break;
}
tempNode = tempNode.next;
}
if (flag) {
tempNode.next = tempNode.next.next;
size--;
}
}
public static int size (Node head) {
Node currentNode = head.next;
int size = 0;
if (head.next == null) {
return 0;
}
while (currentNode != null) {
size++;
currentNode = currentNode.next;
}
return size;
}
public int size () {
return size;
}
//显示链表
public void list () {
if (headNode.next == null) {
System.out.println("链表为空");
return;
}
Node tempNode = headNode.next;
while (true) {
if (tempNode == null) {
break;
}
//输出节点信息
System.out.println(tempNode.toString());
//节点后移
tempNode = tempNode.next;
}
}
//反转链表
public void reversal (Node headNode) {
if (headNode.next == null || size(headNode) == 1) {
return;
}
Node currentNode = headNode.next;
Node tempHeadNode = new Node(0, "", "");
Node tempNode = null;
while (currentNode != null) {
tempNode = currentNode.next;
currentNode.next = tempHeadNode.next;
tempHeadNode.next = currentNode;
currentNode = tempNode;
}
headNode.next = tempHeadNode.next;
}
//合并两个有序链表为一个有序链表
public static SingleLinkedList merge (SingleLinkedList list1, SingleLinkedList list2) {
SingleLinkedList resultList = new SingleLinkedList();
if (list1.size() == 0 && list2.size() > 0) {
resultList = list2;
return resultList;
}
if (list1.size() > 0 && list2.size() == 0) {
resultList = list1;
return resultList;
}
if (list1.size() == 0 && list2.size() == 0) {
return resultList;
}
Stack<Node> stack = new Stack<Node>();
Node currentNode1 = list1.headNode.next;
Node currentNode2 = list2.headNode.next;
while (currentNode1 != null) {
stack.push(currentNode1);
currentNode1 = currentNode1.next;
}
while (currentNode2 != null) {
stack.push(currentNode2);
currentNode2 = currentNode2.next;
}
while (stack.size() > 0) {
resultList.addByOrder(stack.pop());
}
return resultList;
}
public Node getHeadNode() {
return headNode;
}
}
算法实现:
package com.leolee.dataStructure;
import com.leolee.dataStructure.linkedList.Node;
import com.leolee.dataStructure.linkedList.SingleLinkedList;
/**
* @ClassName Test
* @Description:
* @Author LeoLee
* @Date 2020/10/28
* @Version V1.0
**/
public class Test {
/*
* 功能描述: <br>
* 〈给一个链表,两两交换其中的节点,然后返回交换后的链表〉
* @Param: [head 链表中的第一个元素,而非头节点本身,式头节点的下一个]
* @Return: SingleLinkedList
* @Author: LeoLee
* @Date: 2020/11/1 17:33
*/
public static SingleLinkedList exchange(SingleLinkedList list) {
if (list.getHeadNode().next == null || list.getHeadNode().next.next == null) {
return list;
}
Node temp = list.getHeadNode().next;
while (temp != null && temp.next != null) {
int k = temp.next.no;
temp.next.no = temp.no;
temp.no = k;
temp = temp.next.next;
}
return list;
}
public static void main(String[] args) {
Node node1 = new Node(1, "", "");
Node node2 = new Node(2, "", "");
Node node3 = new Node(3, "", "");
Node node4 = new Node(4, "", "");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
Test.exchange(singleLinkedList).list();
}
}