Veränderliche Liste in Scala
In diesem Artikel lernen wir veränderliche Listen in Scala kennen. Standardmäßig sind Listen in Scala unveränderliche Mittel, sobald sie initialisiert sind, können sie nicht aktualisiert werden, aber Scala bietet viele veränderliche Listen.
Schauen wir sie uns nacheinander an.
DoubleLinkedList in Scala
DoubleLinkedList in Scala ist eine verkettete Liste mit zwei Referenzen, prev und next, um zum vorherigen oder nächsten Knoten zu gehen; Wenn wir zwei Referenzen haben, können wir die Liste hin und her durchlaufen.
Schauen wir uns ein Beispiel an.
object MyClass {
class Node(var data: Int,var prev: Node, var next: Node)
{
def this(data: Int)
{
this(data, null, null)
}
}
class DoublyLinkedList(var head:Node,var tail: Node)
{
def this()
{
this(null, null)
}
def insert(x: Int): Unit = {
var node:Node = new Node(x);
if (this.head == null)
{
this.head = node;
this.tail = node;
return;
}
this.tail.next = node;
node.prev = this.tail;
this.tail = node;
}
def show(): Unit = {
if (this.head == null)
{
println("List is empty");
}
else
{
print("\nPrinting list from front to back :\n");
var first: Node = this.head;
while (first!= null)
{
print(" " + first.data);
first = first.next;
}
print("\nPrinting list from back to front:\n");
var last: Node = this.tail;
while (last!= null)
{
print(" " + last.data);
last = last.prev;
}
}
}
}
def main(args: Array[String])
{
var dll: DoublyLinkedList = new DoublyLinkedList();
dll.insert(100);
dll.insert(200);
dll.insert(300);
dll.insert(400);
dll.show(); //to print the list
}
}
Ausgang:
Printing list from front to back :
100 200 300 400
Printing list from back to front:
400 300 200 100
LinkedList in Scala
LinkedList in Scala wird verwendet, um eine einzelne verknüpfte Liste zu erstellen, daher haben wir hier keinen prev-Zeiger. Es wird verwendet, wenn wir zum nächsten Knoten traversieren möchten, der nur in einer Richtung liegt.
Hier können wir also Links erstellen und sie nach Bedarf ändern.
Beispielcode:
case class LinkedList[obj]()
{
var head: node[obj] = null;
def insert(myData: obj) = {
head match {
case null => head = new node(myData,null)
case _ =>
{
var end:node[obj] = head;
while (end.next!= null) {
end = end.next;
}
end.next = new node[obj](myData, null);
}
}
}
def display()
{
if (head != null) {
head.displayLinkedList();
}
println();
}
}
sealed case class node[obj](var data: obj, var next: node[obj])
{
def myData: obj = this.data
def nextPtr: node[obj] = this.next;
def displayLinkedList(): Unit = {
print(data)
if (next!= null) {
print(" -> ")
next.displayLinkedList();
}
}
}
object Main extends App {
var list: LinkedList[Int] = new LinkedList();
list.insert(100);
list.insert(200);
list.insert(300);
list.display();
}
Ausgang:
100 -> 200 -> 300
DoubleLinkedList und LinkedList werden verwendet, um komplexere Listenstrukturen wie mutable.Queues und mutable.lists zu erstellen.
ListBuffer in Scala
ListBuffer ist, wie der Name schon sagt, eine Buffer-Implementierung, die von einer Liste unterstützt wird. Der Hauptvorteil seiner Verwendung besteht darin, dass es die meisten Operationen in linearer Zeit ausführt.
Operationen wie Anhängen und Voranstellen. Daher wird es häufig verwendet, um eine Liste zu implementieren, wenn sie veränderlich sein soll.
Da die Liste unveränderlich ist, verwenden wir ListBuffer, wenn wir eine Liste haben wollen, die sich häufig ändert. Um ListBuffer zu verwenden, müssen wir scala.collection.mutable.ListBuffer in unser Programm importieren.
Syntax:
var one = new ListBuffer[data_type]() //this creates empty buffer
OR
var two = new ListBuffer("apple","orange","watermelon")
Einige der üblichen Operationen, die auf einem ListBuffer ausgeführt werden, sind:
- Wir können
LB+=elementverwenden, um ein Element in konstanter Zeit anzuhängen. - Wir können
LB+=:Bufferverwenden, um ein Element in konstanter Zeit voranzustellen. - Wenn wir mit unserer Liste fertig sind, können wir mit
LB.toListdenListBuffer(veränderlich) in konstanter Zeit inList(unveränderlich) umwandeln.
Beispielcode:
import scala.collection.mutable.ListBuffer
object MyClass {
def main(args: Array[String]) {
var lb = ListBuffer[String]()
lb+= "Apple";
lb+= "Orange";
"dragonFruit"+=:lb //prepending
println(lb);
var result: List[String] = lb.toList
println(result)
}
}
Ausgang:
ListBuffer(dragonFruit, Apple, Orange)
List(dragonFruit, Apple, Orange)
