复制复杂链表(Java)

思路：

     * 1、复制原链表的每个节点 A->B->C =>A->A'->B->B'->C->C' 
     * 
     * 2、A'等 根据A的sibling指向 分别指向正确的位置
     * 
     * 3、拆分链表，偶数序号元素拆出来 组成新链表

代码：

package com.datastructure.link;

/**
 * 复制复杂链表
 * 
 * 请实现函数ComplexListNode clone(ComplexListNode head),复制一个复杂链表。
 * 在复杂链表中，每个结点除了有一个next 域指向下一个结点外，还有一个sibling 指向链表中的任意结点或者null
 * 
 */
public class CopyComplexNode {

	private static final int ADD_NUM = 100;
	
	static class Node {
		int value;
		Node next;
		Node sibling;
		public Node(int value) {
			this.value = value;
		}
		
		// 便于打印不能作用与循环链表
        @Override
        public String toString() {
            if (this.next == null) {
                return String.valueOf(this.value);
            }
            return this.value + "->" + this.next.toString() + 
            	       (this.sibling == null ? "" : "(" + this.sibling.value + ")");
        }
	}
	

	
	/**
	 * 1、复制原链表的每个节点 A->B->C =>A->A'->B->B'->C->C' 
	 * 
	 * 2、A'等 根据A的sibling指向 分别指向正确的位置
	 * 
	 * 3、拆分链表，偶数序号元素拆出来 组成新链表
	 */
	public static Node clone(Node head) {
		if (head == null) {
			throw new RuntimeException("link is empty");
		}
		
		simpleCopyEle(head);
		
		copySibling(head);
		
		return getCopyLink(head);
		
	}
	
	private static Node simpleCopyEle(Node head) {
		Node curNode = head;
		
		while (curNode != null) {
			Node copy = new Node(curNode.value + ADD_NUM);
			
			// 缓存原来的下一个元素
			Node next = curNode.next;
			
			// 插入新元素
			copy.next = next;
			curNode.next = copy;
			
			// 指针后移
			curNode = next;
			
		}
		
		return head;
	}
	
	
	private static Node copySibling(Node head) {
		Node curNode = head;
		
		while (curNode != null) {
			Node nextCurNode = curNode.next.next;
			
			// 复制sibling
			if (curNode.sibling != null) {
				curNode.next.sibling = curNode.sibling.next;
			}
			
			curNode = nextCurNode;
		}
		
		return head;
	}
	
	/**
	 * 返回偶数序号元素组成的链表
	 */
	private static Node getCopyLink(Node head) {
		// 当前第一个偶数节点
		Node newNode = head.next;
		Node curNewNode = newNode;
		
		while (curNewNode != null && curNewNode.next != null) {
			// 缓存下一个复制出来的节点
			Node tmpNode = curNewNode.next.next;
			// 当前节点指向下一个复制出来的节点
			curNewNode.next = tmpNode;
			// 指针后移到下一个复制的节点
			curNewNode = tmpNode;
		}
		
		return newNode;
	}
	
	
    public static void main(String args[]) {
        
		Node head = createTestLinkedList(5, new Node(4));
        // 原链表
        System.out.println("origin link: " + head);

        // 删除重复元素
        System.out.println("copy link: " + clone(head));
        
    }
    
    private static Node createTestLinkedList(int n, Node addNode) {
        Node head = new Node(0);
        Node head1 = new Node(0);
        head1.sibling = head;
        head.next = head1;
        Node curNode = head1;
        int count = 1;
        for (int i = 1; i < n; i++) {
            curNode.next = new Node(i);
            curNode = curNode.next;
            if (i == 2 && count >= 0) {
            	i--;
            	count--;
            }
        }
        curNode.next = addNode;
        return head;
    }

}

参考：

复制复杂链表：https://blog.csdn.net/derrantcm/article/details/46721767