数据结构之链表面试题汇总（二）-有序单向链表的合并、单向链表反转

date: 2016-08-18 9:13:00

title: 数据结构之链表面试题汇总（二）-有序单向链表的合并、单向链表反转

categories: 数据结构

版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可

所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。

合并两个有序的单向链表，合并之后的链表依然有序【出现频率高】（剑指offer，题17）

思路:

若两个链表本来有序，在合并的时候，可以参照一下归并排序的归并部分，原理一样。

先比较两条链表的节点，先把小的放进新链表，当其中一条链表到达最后一个节点的时候结束循环

在结束循环后判断那条链表为空，然后直接设置下一个节点为另外一个链表的节点即可，这样就可以把剩下的节点都连接上

图解:

public class MergeList {
public static Node mergeList(Node head1, Node head2) {
// first judge 2 head is null together
if (head1 == null && head2 == null) {
throw new RuntimeException("the 2 of them are null");
}
// judge if one of them is null then return another
if (head1 == null)
return head2;
if (head2 == null)
return head1;

// declare two variables to record the newHead and current pointers
Node newHead;
Node current;

// get the first in the new node
if (head1.getRecord() < head2.getRecord()) {
newHead = head1;
current = head1;
head1 = head1.getNext();
} else {
newHead = head2;
current = head2;
head2 = head2.getNext();
}

// loop that put the less one to the list and update the position while
// one of them is null
while (head1 != null && head2 != null) {
if (head1.getRecord() < head2.getRecord()) {
current.setNext(head1);
current = current.getNext();
head1 = head1.getNext();
} else {
current.setNext(head2);
current = current.getNext();
head2 = head2.getNext();
}
}
// if one of them are null which indicates that the other is not null
// and put
if (head1 == null) {
current.setNext(head2);
}
if (head2 == null) {
current.setNext(head1);
}
// is to the list
// return new list
return newHead;
}

}

测试代码： 第二个链表中的元素都比第一个链表的元素大

public class ReverseLinkedListTest {

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

node1.setNext(node2);
node2.setNext(node3);
node3.setNext(node4);

Node list1 = new Node(7);
Node list2 = new Node(8);
Node list3 = new Node(9);
Node list4 = new Node(10);
list1.setNext(list2);
list2.setNext(list3);
list3.setNext(list4);

RecustionAllElementOfLinkedList.printAllElements(MergeList.mergeList(
node1, list1));
}

}

运行结果：



测试代码二：第二个链表中有与第一个链表相同的元素：

public class ReverseLinkedListTest {

/**
* @param args
*/
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);

node1.setNext(node2);
node2.setNext(node3);
node3.setNext(node4);

Node list1 = new Node(1);
Node list2 = new Node(2);
Node list3 = new Node(6);
Node list4 = new Node(7);
list1.setNext(list2);
list2.setNext(list3);
list3.setNext(list4);

RecustionAllElementOfLinkedList.printAllElements(MergeList.mergeList(
node1, list1));
}

}

运行结果：

单链表的反转【出现频率最高】（剑指offer，题16）

思路:

可以考虑用栈来存放链表中的元素，然后再通过弹栈来存入新链表中来实现该功能，但是这样做不高效

也可以考虑用数组存放链表中的元素，然后通过倒序获取数组中的元素来实现

在这里主要讨论使用递归实现单向链表的反转

首先判断节点是否为空，为空抛异常

接着得到当前节点的下一个节点

把当前节点的下一个节点设置成null

把下一个节点作为参数递归调用，返回的是最后一个节点

把下一个节点的下一个节点设置成当前节点，下一个节点为5 当前节点为4 结果为5.setNext(4)

还有4 3，3 2 ，2 1 完成之后返回递归返回的节点，即新链表的头节点

图解



代码实现：包含使用栈、双指针、递归的方法

public class ReverseLinkedListUtil {
/**
* use stack to reverse single-direction LinkedList
*
* @param head
*            the head of a LinkedList
* @return the new head of a LinkedList
*/
public static Node reverseByStack(Node head) {
Stack<Node> nodes = new Stack<Node>();
if (head == null) {
throw new RuntimeException("the Node is null !");
}
// put all the node to the stack
while (head != null) {
nodes.push(head);
head = head.next;
}
// get all the node in the stack
head = nodes.pop();
Node curNode = head;
while (!nodes.isEmpty()) {

// update the next of the node
Node nextNode = nodes.pop();
nextNode.setNext(null);
curNode.setNext(nextNode);
curNode = nextNode;

}
// return the new head
return head;
}

/**
* use 2 pointers to reverse the single-direction LinkedList
*
* @param head
*            the head of a single-direction LinkedList
* @return the new head of a single-directionLinkedList
*/
public static Node reverseByPointer(Node head) {
// define the previous node to record the previous node
Node previous = null;
// judge that the current node is null
while (head != null) {
// if true move the 2 pointers backward
// get the next node and record it
Node next = head.getNext();
// set the next.next to previous
head.setNext(previous);
// set the previous to current (head)
previous = head;
// set the next to next
head = next;
}
// else break out the loop
return previous;
}

/**
* use recursion to reverse the single-direction LinkedList
*
* @param head
*            the head of the LinkedList
* @return the new-head of the LinkedList that has been reversed
*/
public static Node reverseByRecur(Node head) {
// if the tail is reached return it
if (head == null || head.next == null)
return head;
// get the next node
Node nextNode = head.getNext();
// set the current node's next node to null
head.setNext(null);
// recursion
Node recursionResult = reverseByRecur(nextNode);
// set the next node's next node to current
nextNode.setNext(head);
// return the value that was returned from the recursion
return recursionResult;
}

}

测试代码：

public class ReverseLinkedListTest {

/**
* @param args
*/
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);
Node node5 = new Node(5);
node1.setNext(node2);
node2.setNext(node3);
node3.setNext(node4);
node4.setNext(node5);

RecustionAllElementOfLinkedList.printAllElements(ReverseLinkedListUtil
.reverseByRecur(node1));
}

}

运行结果：