面试题26:复杂链表的复制
复制一个复杂链表,这个链表除了next指针,还有指向任意一个结点的sibling指针或空指针。
思路1:一个效率很低的方法:分两步,先复制一遍next链表,然后设置sibling指针。但由于不知道它指向的位置,所以要遍历一遍链表(在原链表中,从头走了几步,在新链表中,也走几步,这就能确定位置了),这样每个结点设置sibling都要经过O(n)步,总复杂度O(n^2)。
思路2:用空间换时间:和上边一样还是两步,区别在于第一步的时候要记录sibling的配对信息到一个哈希表中,这样第二步就能在O(1)时间内完成单个节点的sibling的设置。用O(n)的空间复杂度换来了O(n)的时间复杂度。
思路3:不用辅助空间实现O(n)的效率:三步,1,创建结点n的复制n',n指向n',n'指向下一个原始结点。2,设置sibling,原始结点指向谁,复制的结点就指向对应的复制。3,把这个长链表拆分成两个链表,完成复制。
本题Java实现如下:
public class ComplexList {
//调用
ComplexListNode clone(ComplexListNode head){
cloneNodes(head);
connectSiblingNodes(head);
return reconnectNodes(head);
}
//第一步,复制结点
void cloneNodes(ComplexListNode head){
ComplexListNode p = head;
while(p != null){
ComplexListNode cloned = new ComplexListNode(p.value);
cloned.next = p.next;
p.next = cloned;
p = cloned.next;
}
}
//第二步,设置sibling
void connectSiblingNodes(ComplexListNode head){
ComplexListNode p = head;
while(p != null){
if(p.sibling != null){
p.next.sibling = p.sibling.next;
}
p = p.next.next;
}
}
//第三步,拆分
ComplexListNode reconnectNodes(ComplexListNode head){
ComplexListNode p = head;
ComplexListNode clonedHead = null;
ComplexListNode tempHead = null;
if(p != null){
clonedHead = p.next;
tempHead = clonedHead;
p.next = clonedHead.next;
p = p.next;
}
while(p != null){
tempHead.next = p.next;
tempHead = tempHead.next;
p.next = tempHead.next;
p = p.next;
}
return clonedHead;
}
//打印
void print(ComplexListNode head){
if(head == null ) return;
while(head != null){
System.out.println(head.value);
if(head.sibling != null){
System.out.println(head.sibling);
}
head = head.next;
}
}
public static void main(String[] args) {
ComplexList test = new ComplexList();
ComplexListNode root=new ComplexListNode(0);
ComplexListNode node1=new ComplexListNode(1);
ComplexListNode node2=new ComplexListNode(2);
ComplexListNode node3=new ComplexListNode(3);
ComplexListNode node4=new ComplexListNode(4);
root.next = node1;
root.sibling = node2;
node1.next = node2;
node1.sibling = node4;
node2.next = node3;
node3.next = node4;
test.print(root);
test.print(test.clone(root));
}
}
class ComplexListNode{
int value;
ComplexListNode next,sibling;
ComplexListNode(int x){
value = x;
}
}
面试题27:二叉搜索树与双向链表(递归)
将二叉搜索树转换成一个排序的双向链表,要求不能创建新的结点,只能改变树中结点的指向。
思路:搜索树的中序遍历结果是排好序的,如果把它变成排序的双向链表,根结点一定和左子树里最大的结点相连,也一定和右子树最小的结点相连。然后对于左右子树的根结点,递归处理。
本题Java实现如下:
public class Convert {
private BiTree convert(BiTree root){//这里返回二叉树表示的双向链表
BiTree lastNode = null;//指向双向链表尾端(值最大的结点)
BiTree headNode = convertNode(root,lastNode);//后边函数返回的是双向链表尾结点,我们需要头结点
while(headNode != null && headNode.left != null){
headNode = headNode.left;
}
return headNode;
}
private BiTree convertNode(BiTree root,BiTree lastNode){
if(root == null){
return null;
}
BiTree current = root;
//按照中序遍历左根右的顺序来,左
if(current.left != null){
lastNode = convertNode(current.left, lastNode);
}
//根,此时lastNode应是左子树的最大值,与根相连后,根变成了新的lastNode
current.left = lastNode;
if(lastNode != null){
lastNode.right = current;
}
lastNode = current;
//右
if(current.right != null){
lastNode = convertNode(current.right, lastNode);
}
return lastNode;
}
public static void main(String[] args) {
Convert test = new Convert();
BiTree A1 = new BiTree(4);
BiTree A2 = new BiTree(2);
BiTree A3 = new BiTree(5);
BiTree A4 = new BiTree(1);
BiTree A5 = new BiTree(3);
A1.left = A2;
A1.right = A3;
A2.left = A4;
A2.right = A5;
BiTree a = test.convert(A1);
while(a != null){
System.out.println(a.value);
a = a.right;
}
}
}
class BiTree{
int value;
BiTree left,right;
BiTree(int x){
value = x;
}
}