Énumération indirecte ou classe, laquelle devrais-je utiliser pour construire des structures de données de base?

Question

Lorsque j'ai essayé de pratiquer une structure de données de base telle que Linked/Doublement Lié/Recyclé Lié/Recyclé Liste Doublement Liée, Arbre AVL, Arbre Rouge-Noir, B-Tree et Treap en les implémentant dans Swift 2, j'ai décidé de faire de telles choses en profitant de la nouvelle fonctionnalité de Swift 2: enum indirect, car enum fait un nœud vide et un nœud rempli plus sémantique que la classe. Mais bientôt, il a été constaté que pour les listes chaînées non recyclables, renvoyer le noeud inséré après l'insertion d'un élément n'a aucun sens car la valeur renvoyée est un type de valeur mais pas un type de référence. Il est dit que vous ne pouvez pas accélérer l'insertion suivante en écrivant des informations directement dans la valeur retournée car il s'agit d'une copie du nœud inséré mais pas d'une référence au nœud inséré. Ce qui est pire, c'est que muter un nœud indirect enum signifie écrire tout le paquet de données de la valeur associative, ce qui introduit définitivement une consommation inutile de ressources système, car la valeur associative dans chaque cas d'énumération est un tuple par essence, qui est une sorte de données contiguës dans la mémoire par essence, qui est la même à struct mais n'a pas d'accesseur de propriété pour permettre un petit groupe d'écriture de données.

Alors, lequel dois-je utiliser pour construire ces structures de données de base? Enum indirect ou classe?

Answer 1

Eh bien, il n'a pas d'importance si elle est rapide 1 ou 2 la cause rapide au moment Enum et Structures sont value types tout Classes sont appelés par référence. Puisque vous voulez utiliser des structures de données dans votre code et que vous l'appeliez vous-même en les appelant par valeur, ce n'est pas bon. Vous devrez utiliser un Class pour que votre code fasse ce que vous voulez qu'il fasse. Voici un exemple d'une liste chaînée en utilisant un Class:

 class LLNode<T> 
    { 
    var key: T? var next: LLNode? var previous: LLNode? 
    } 

      //key printing 
     func printAllKeys() 
    { 
    var current: LLNode! = head; //assign the next instance 
    while(current != nil) 
    { 
    println("link item is: \(current.key)") 
    current = current.next 
    } 
    } 

public class LinkedList<T: Equatable> 
{ //create a new LLNode instance private 
var head: LLNode<T> = LLNode<T>() //append a new item to a linked list 
func addLink(key: T) 
{ //establish the head node 
if (head.key == nil) 
{ 
head.key = key; 
return; 
} //establish the iteration variables 
var current: LLNode? = head 
while (current != nil) 
{ 
if (current?.next == nil) 
{ 
var childToUse: LLNode = LLNode<T>() 
childToUse.key = key; 
childToUse.previous = current 
current!.next = childToUse; 
break; 
} 
current = current?.next 
} //end while 
} ///end function 

pour plus d'exemples en utilisant des structures rapides et données s'il vous plaît punirai: data structures swift

Conclusion: L'utilisation Class si vous voulez appeler par référence usage autre Enum ou Struct