使用 scala 实现单向链表

Posted 2023-02-17 做人要厚道2013

单向链表是一种最简单的链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。

/**
  * Author lzc
  * Date 2019-11-27 08:40
  */
object SinglyLinkedListDemo 
    def main(args: Array[String]): Unit = 
        val list = new SinglyLinkedList[Int]()
        list.add(10)
        list.add(20)
        list.add(30)
        
        list.printInfo()
        list.delete(20)
        list.add(40)
        list.printInfo()
    


/**
  *
  * 没有头指针!!!!!!!   过时
  * 单向列表
  *
  *
  *
  * @tparam T 列表中存储的元素的类型
  */
@deprecated
class SinglyLinkedList[T] 
    
    // 头结点
    private var head: Node = _
    // 为了提高添加的效率, 设置一个尾结点
    private var tail: Node = _
    
    /**
      * 添加元素
      *
      * @param ele
      * @return 表示添加成功
      */
    def add(ele: T): Boolean = 
        if (head == null)  //如果是第一次添加元素, 则第一个节点置为 head 节点. 尾结点和头节点一致
            head = Node(ele, null) // 头节点一旦确定, 后续不再变化(除非删除)
            tail = head //
         else  // 不是第一次添加, 则让尾节点的 next 指向新节点, 然后再更新尾节点到新节点
            tail.next = Node(ele, null)
            tail = tail.next // tail 指向新节点
        
        true
    
    
    /**
      * 从链表中删除指定的元素
      *
      * @param ele
      * @return 删除是否成功
      */
    def delete(ele: T): Boolean = 
        // 如果头节点为 null, 表示没有元素, 所以删除失败
        if (head == null) return false
        // 如果头节点就是要删除, 则删除当前的头节点, 并把下一个节点设置为头节点. 如果删除的节点也是尾节点,则需要更新尾节点
        if (head.vale == ele) 
            if (head.eq(tail))  // 必须比较是否为同一个对象. 等价于 java 的比较地址值是否相等 ==
                tail = head.next // 更新尾节点
            
            head = head.next // 更新头节点
            return true
         else  // 如果头节点不是要删除的节点, 则遍历后面的节点
            var currentNode: Node = head // 当前节点
            var nextNode: Node = currentNode.next // 下一个节点
            while (nextNode != null) 
                if (nextNode.vale == ele)  // 删除
                    currentNode.next = nextNode.next // 让当前节点指向下一个节点的下一个节点
                    if (nextNode.eq(tail))  // 如果要删除的节点是尾节点, 尾节点需要指向当前节点
                        tail = currentNode
                    
                    return true
                
                currentNode = nextNode
                nextNode = currentNode.next
            
        
        
        false
    
    
    /**
      * 测试指定的元素是否存在
      *
      * @param ele
      */
    def contains(ele: T): Boolean = 
        if (head == null) return false
        
        var tmp: Node = head
        do 
            if (tmp.vale == ele) return true
            tmp = tmp.next
         while (tmp != null)
        false
    
    
    /**
      * 打印链表的元素
      */
    def printInfo(): Unit = 
        if (head == null) return
        
        var tmp: Node = head
        do 
            print(tmp.vale + "->")
            tmp = tmp.next
         while (tmp != null)
        
        println()
    
    
    /**
      * 链表中的节点
      *
      * @param vale
      * @param next
      */
    case class Node(vale: T, var next: Node)