C# lista concatenata di attuazione

Mentre cercava di capire come un singolarmente elenco può essere implementato in C#, mi sono imbattuto nel link qui sotto :

Creazione di una semplice lista collegata.

Tuttavia, sono nuovo di C#, ho confuso con la sintassi indicata nella parte iniziale della discussione di cui sopra. Una classe denominata Nodo viene dichiarato e c’è un’altra istruzione all’interno di una classe dichiarata come “public Nodo successivo”. Questa dichiarazione è chiamato un costruttore? Si prega di aiuto.

public class Node {
    public Node next;
    public Object data;
 }

OriginaleL’autore user3011489 | 2013-11-20

4 Replies
  1. 14

    In una semplice lista semplicemente concatenata di attuazione del Node tipo contiene un riferimento all’elemento successivo della lista, che è ciò che il next campo in Node tipo che hai postato. Questo riferimento è utilizzato per consentire l’iterazione dell’elenco.

    Allegando LinkedList classe (o come volete chiamarlo) conterrà un singolo Node riferimento al primo elemento della lista. A partire dal primo nodo è quindi possibile passaggio attraverso l’elenco, ottenere l’ next campo. Quando next è null allora hai raggiunto la fine della lista.

    Prendere questo codice, ad esempio:

    public class LinkedList
    {
        public class Node
        {
            //link to next Node in list
            public Node next = null;
            //value of this Node
            public object data;
        }
    
        private Node root = null;
    
        public Node First { get { return root; } }
    
        public Node Last 
        {
            get
            {
                Node curr = root;
                if (curr == null)
                    return null;
                while (curr.next != null)
                    curr = curr.next;
                return curr;
            }
        }
    }

    Il First proprietà restituisce semplicemente il nodo principale, che è il primo nodo della lista. Il Last proprietà inizia dal nodo principale e scorre la lista fino a quando non trova un nodo il cui next proprietà è null, indicando la fine della lista.

    Questo rende semplice per aggiungere elementi alla lista:

    public void Append(object value)
    {
        Node n = new Node { data = value };
        if (root == null)
            root = n;
        else
            Last.next = n;
    }

    Per eliminare un nodo per nodo che lo precede nell’elenco, quindi aggiornare il next link da che nodo a punto al nodo successivo a quello di essere eliminato:

    public void Delete(Node n)
    {
        if (root == node) 
        {
            root = n.next;
            n.next = null;
        }
        else
        {
            Node curr = root;
            while (curr.next != null)
            {
                if (curr.next == n)
                {
                    curr.next = n.next;
                    n.next = null;
                    break;
                }
                curr = curr.next;
            }
        }
    }

    Ci sono alcune altre operazioni che si possono eseguire, come l’inserimento di valori in posizioni nell’elenco, nodi di scambio, etc. L’inserimento di un nodo è veloce, la prima è lento poiché è necessario individuare il nodo precedente. Se si vuole veramente veloce ‘inserisci-prima”, è necessario utilizzare un elenco collegato doppiamente dove il Node tipo ha sia next e previous link.


    Per espandere la tua domanda nel commento…

    In C# ci sono due classificazioni di base che tutti i tipi di cadere: i tipi di valore e tipi di riferimento. I nomi riflettono il modo in cui sono passati tra i blocchi di codice: tipi di valore sono passati per valore (valore viene copiato in una nuova variabile), mentre i tipi di riferimento sono passati per riferimento (riferimento/puntatore viene copiato in una nuova variabile). La differenza è che le modifiche a un tipo di valore parametro non ha effetto sul chiamante copia del valore, mentre le modifiche apportate a un riferimento tipo parametro verrà riflesso del chiamante copia del riferimento.

    Lo stesso è vero per l’assegnazione di valori e di riferimenti a variabili. In seguito, il valore di a non è cambiato quando b è cambiato:

    int a = 0;
    int b = a;
    b = 1;

    Che è abbastanza intuitivo. Che cosa potrebbe viaggio si è che in C# un struct è anche un tipo di valore:

    public struct test
    {
        public string value;
    }
    
    static void Main()
    {
        test a;
        a.value = "a";
        test b = a;
        b.value = "b";
    
        Console.WriteLine("{0} {1}", a.value, b.value);
    }

    Di cui sopra darà l’uscita a b perché quando hai ricevuto a per b una copia è stata fatta. Ma se vogliamo cambiare la struttura di classe:

    public class test
    {
        public string value;
    }
    
    static void Main()
    {
        test a = new test(); //Note the 'new' keyword to create a reference type instance
        a.value = "a";
        test b = a;
        b.value = "b";
        Console.WriteLine("{0} {1}", a.value, b.value);
    }

    Perché la variabile b è un punto di riferimento per la stesso oggetto come una variabile a riferimenti, l’output qui sarà b b. Le due variabili di riferimento, lo stesso oggetto.

    Se sei venuto da C/C++ o altre simili la lingua, si può pensare di riferimento tipo di variabili come puntatori. Non è proprio la stessa, e C#, effettivamente, avere puntatori (che sono nascosti dalla normale codice gestito), ma è abbastanza vicino. Fino a quando puntano un istanza del tipo che non è completamente utilizzabile. Proprio come un char* in C/C++ non è particolarmente utile fino al punto da qualche parte.

    Giuseppe Alhabari (ha scritto un articolo in cui si parla di valore e tipi di riferimento: C# Concetti: vs Valore di Riferimento Tipi di. Vale la pena di leggere, così come molto di ciò che scrive. Vorrei, inoltre, consigliamo di prendere in considerazione ottenere uno dei suoi C# Parole libri.

    Nodo curr = root; Scusa, se questa è una domanda stupida, ma sto solo cercando di diventare meglio a C# e non si vuole fare qualsiasi ipotesi. Quando si fa questa dichiarazione, ho corretto la comprensione che si sono instatiating un oggetto di tipo Nodo? Se è così, quello che mi confonde è come lo spazio di memoria verrà assegnato perché c’è un’altra dichiarazione di “pubblica Nodo successivo” all’interno quando “Nodo corrente” viene eseguita?
    No, la dichiarazione è un variabile che può contenere un riferimento, che è concettualmente simile a un puntatore in C o C++. Questo è vero per tutte le variabili di classe. Per creare un’istanza della classe in oggetto, è necessario utilizzare il new parola chiave.

    OriginaleL’autore Corey

  2. 2

    C’è un modo semplice per creare la Lista concatenata. Cerchiamo di capire il concetto. Se il concetto è chiaro, allora si può capire la logica stessa. Lista concatenata è il Nodo con due sezioni. Uno ha dati valore e l’altro è l’indirizzo di riferimento del nodo successivo. Prendere lo sguardo nel codice riportato di seguito:

    Prima di tutto Dobbiamo creare un Elenco Collegato Nodo di Classe

    ///<summary>
    ///Creating the Real World Entity of Linked List Node
    ///</summary>
    public class LinkedListNode
    {
        public Object Value { get; set; }
    
        public LinkedListNode Next { get; set; }
    
    }

    Qui la classe ha Valore e Titolare di mantenere il riferimento del Nodo successivo nella sequenza. Avanti abbiamo bisogno di creare una Lista Collegata stesso

    ///<summary>
    ///Creating the Linked List Class Itself. It defines the First and Last Nodes of Linked List
    ///</summary>
    public class LinkedList
    {
        public LinkedListNode First { get; set; }
        public LinkedListNode Last { get; set; }
    
        ///<summary>
        ///Method to Add items into the Linked List
        ///</summary>
        ///<param name="_value"></param>
        public void AddToLinkedList(object _value)
        {
            LinkedListNode node = new LinkedListNode();
            node.Value = _value;
    
            if (First == null)
            {
                First = node;
                Last = node;
            }
            else
            {
                Last.Next = node;
                Last = node;
            }
        }
    
        ///<summary>
        ///Method to display all items. We can further implement the IEnumerable interface
        ///to Yield IEnumerator Interface.
        ///</summary>
        public void DisplayAllItems()
        {
            LinkedListNode current = First;
            while (current != null)
            {
                Console.WriteLine(current.Value);
                current = current.Next;
            }
        }
    }

    Qui, la Chiave è quello di Aggiungere elementi alla Lista Collegata. Prima abbiamo bisogno di controllare se la lista non esiste o non. Controlliamo la Prima o la Testa Nodo della Lista collegata. Se è vuota, si assegna il nodo come primo punto di ingresso. In questa fase l’Ultimo elemento è il primo elemento stesso.

    Ora questo è come si aggiungere e visualizzare gli elementi

    class Program
    {
        static void Main(string[] args)
        {
            LinkedList singlyLinkedList = new LinkedList();
            singlyLinkedList.AddToLinkedList(4);
            singlyLinkedList.AddToLinkedList(5);
            singlyLinkedList.AddToLinkedList(7);
            singlyLinkedList.AddToLinkedList(2);
            singlyLinkedList.AddToLinkedList(1);
            singlyLinkedList.AddToLinkedList(10);
    
            singlyLinkedList.DisplayAllItems();
            Console.ReadLine();
        }
    }

    Fammi sapere se ha senso 🙂

    OriginaleL’autore Abhinav Rao

  3. 0

    Ricordare che un Elenco Collegato non contiene solo dati, ma un riferimento /puntatore al nodo successivo della lista. Dal momento che le classi sono tipi di riferimento in C#, non si vede alcun sintassi speciale che si sarebbe altrimenti vedi in C o C++.

    struct Node
    {
        int Number;
        struct Node* next; /* this points to the next node in the linked list */
    };
    Ringrazio tutti per il vostro aiuto. Dopo aver letto le descrizioni di campo sul sito web di Microsoft, la mia comprensione è più chiaro. Tuttavia, solo una domanda: se una dichiarazione di campo ha lo stesso nome della classe, c’è un termine per definire questo tipo di campo?
    Sono sicuro che c’è… come ci sembra essere un termine per tutto… ma io non sono a conoscenza di esso o non può pensare di fuori della parte superiore della mia testa. Penso che l’implementazione di soluzioni a problemi quali liste collegate, doppiamente liste collegate, sono aggravati quando si utilizza un linguaggio di alto livello che abstracts tanto da parte dello sviluppatore.
    Grazie per il vostro aiuto.

    OriginaleL’autore Inisheer

Lascia un commento