复杂链表复制

问题描述：

请实现函数ComplexListNode Clone(ComplexListNode head)，复制一个复杂链表。在复杂链表中，每个结点除了有一个Next指针指向下一个结点外，还有一个Sibling指向链表中的任意结点或者NULL。

解题思路：

1. 根据原始链表的每个结点N创建对应的复制节点，并添加到每个节点之后，行成一个新的链表

2. 遍历新的链表，重置复制的节点的random指针为原指针的后一个地址

3. 拆分出两个链表

package main

import (
	"fmt"
)

type Node struct {
	Value int
	Next *Node
	Random *Node
}

type List struct {
	head *Node
	tail *Node
	size int
}

func (l *List) Length() int {
	cnt := 0 
	node := l.head
	for node != nil {
		cnt ++
		node = node.Next
	}
	return cnt
}

func (l *List) Append(v *Node) bool {
	if v == nil {
		return false
	}
	
	if l.size == 0 {
		l.head = v
		l.tail = v
		l.size += 1
		return true
	}

	l.tail.Next = v
	l.tail = v
	l.size += 1
	return true	
}

func (l *List) Insert(index int, v *Node) bool {
	if v == nil || index > l.size {
		return false
	}

	if index == 0 {
		v.Next = l.head
		l.head = v
		if l.size == 1{
            l.tail = v
        }
		l.size += 1
		return true
	}

	ptr := l.head
	for i := 1; i < index; i++ {
		ptr = ptr.Next
	}
	v.Next = ptr.Next
	ptr.Next = v
	if l.size == index {
		l.tail = v
	}
	l.size += 1
	return true
}

func (l *List) Delete(index int) (*Node, bool) {
	if index >= l.size {
		return nil, false
	}

	if index == 0 {
		head := l.head
		l.head = head.Next
		if l.size == 1{
            l.tail = nil
        }
		l.size-=1
		return head, true
	}

	ptr := l.head
	for i := 1; i < index; i++ {
		ptr = ptr.Next
	}
	next := ptr.Next
	ptr.Next = next.Next
	if l.size == index{
		l.tail = ptr
	}
	l.size -= 1

	return next, true
}

func (l *List) Display() {
	if l == nil {
		return
	}
	ptr := l.head 

	i := 1
	for ptr != nil {
		fmt.Println("i :", i, " value: ", ptr.Value)
		if ptr.Random != nil {
			fmt.Println("random :", i, " ptr.Random value: ", ptr.Random.Value)
		}
		ptr = ptr.Next
		i++
	}
}

func (l *List) buildNodes(index int, random int) bool {
	if index > l.size || random > l.size {
		return false
	}
	if index == random {
		return false
	}

	var node, randomNode *Node
	ptr := l.head
	for i := 1; i <= l.size; i++ {
		if index == i {
			node = ptr
		}
		if random == i {
			randomNode = ptr
		}
		ptr = ptr.Next
	}
	node.Random = randomNode
	return true
}

func New(nums []int) *List{
	l := &List{
		size: 0,
	}
	for _, v := range nums {
		l.Append(&Node{
			Value: v,
		})
	}
	return l
}

func clone(list *List) *List  {
	if list == nil {
		return nil
	}

	ptr := list.head
	size := list.size
	for i := 1; i <= size; i++ {
		next := ptr.Next
		add := &Node{
			Value: ptr.Value,
			Random: ptr.Random,
		}
		ptr.Next = add
		add.Next = next
		ptr = next
	}

	ptr = list.head
	for i := 1; i <= size * 2; i++ {
		if i % 2 == 0 {
			if ptr.Random != nil {
				ptr.Random = ptr.Random.Next
			}
		}
		ptr = ptr.Next
	}


	newList := &List{}
	ptr = list.head
	newPtr := newList.head
	for i := 1; i <= size * 2; i++ {
		if i % 2 == 0 {
			if newPtr == nil {
				newPtr = ptr
				newList.head = newPtr
			} else {
				newPtr.Next = ptr
				newPtr = ptr
			}
		}
		next := ptr.Next
		if ptr.Next != nil {
			ptr.Next = ptr.Next.Next
		} else {
			ptr.Next = nil
			newList.tail = ptr
		}
		ptr = next
	}
	return list
}

func main()  {
	list := New([]int{1, 2, 3, 5, 6})
	_ = list.buildNodes(1, 3)
	_ = list.buildNodes(2, 5)
	_ = list.buildNodes(4, 2)
	list.Display()

	newList := clone(list)
	newList.Display()
}