Kotlin 实现两个排序双向循环链表的交集

/**
 * 计算两个已排序双向循环链表的交集，并从原链表中移除交集元素。
 *
 * @param list1 第一个链表的头节点。
 * @param list2 第二个链表的头节点。
 * @param cmp 用于比较链表元素的比较器。
 * @return 一个新的双向链表，其中包含两个输入链表的交集元素，且不包含重复元素。
 */
fun <E> intersection(list1: Node<E>, list2: Node<E>, cmp: Comparator<E>): Node<E>? {
    var list: Node<E>? = null
    var temp = list1
    var temp2 = list2
    var count = 0
    var head : Node<E>? = null

    while (temp.next?.value != null){
        temp = temp.next!!

        while(temp2.next?.value !=null){
            temp2 = temp2.next!!
            if(cmp.compare(temp.value,temp2.value)==0 ){
                var novo = deleteNode(temp)
                if (list != null){
                    novo.previous = list
                    list.next = novo
                }
                list = novo
                count ++
                if(count==1){
                    list.previous = null
                    head = list
                }

                deleteNode(temp2)
                break;
            }

        }
        temp2 = list2

    }

    return head
}

/**
 * 从链表中删除指定的节点。
 *
 * @param node 要删除的节点。
 * @return 被删除的节点。
 */
fun <E> deleteNode(node : Node<E>): Node<E>{

    var prev = node.previous
    var next = node.next

    while(next!=null && next!!.value == node.value ){ // 消除重复项
        next = next.next
    }

    if (prev != null) {
        prev.next = next
    }
    if (next != null) {
        next.previous = prev
    }

    return node
}

// 节点类的定义
class Node<E> {
    var previous: Node<E>? = null
    var next: Node<E>? = null
    var value: E? = null
}

fun main() {
    // 创建链表1: 1 <-> 2 <-> 3 <-> 4 (循环链表)
    val node1 = Node<Int>().apply { value = 1 }
    val node2 = Node<Int>().apply { value = 2 }
    val node3 = Node<Int>().apply { value = 3 }
    val node4 = Node<Int>().apply { value = 4 }

    node1.next = node2
    node2.previous = node1
    node2.next = node3
    node3.previous = node2
    node3.next = node4
    node4.previous = node3
    node4.next = node1 // 形成循环

    val list1 = node1

    // 创建链表2: 2 <-> 4 <-> 6 (循环链表)
    val node5 = Node<Int>().apply { value = 2 }
    val node6 = Node<Int>().apply { value = 4 }
    val node7 = Node<Int>().apply { value = 6 }

    node5.next = node6
    node6.previous = node5
    node6.next = node7
    node7.previous = node6
    node7.next = node5 // 形成循环

    val list2 = node5

    // 定义比较器
    val cmp = Comparator<Int> { a, b -> a.compareTo(b) }

    // 计算交集
    val intersectionList = intersection(list1, list2, cmp)

    // 打印交集链表
    var current = intersectionList
    print("Intersection List: ")
    while (current != null) {
        print("${current.value} ")
        current = current.next
    }
    println()
}