n° 185
Maggio/Giugno 2013
Maggio 25, 2013, 08:25:30 am *
Benvenuto! Accedi o registrati.
Hai dimenticato l'e-mail di attivazione?

Accesso con nome utente, password e durata della sessione
Notizia:
 
   Indice   Linux Windows Techassistance Gameassistance videogame hardware Aiuto Ricerca Agenda Downloads Accedi Registrati  

* Messaggi recenti
Messaggi recenti
Pagine: [1]   Vai giù
  Stampa  
Autore Discussione: [C++]aiuto con liste  (Letto 1154 volte)
0 utenti e 1 Utente non registrato stanno visualizzando questa discussione.
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« inserita:: Maggio 28, 2012, 09:54:48 am »

Ciao ragazzi
mi aiutate per favore con le operazioni sulle liste alcune non le capisco?
Anzitutto vi posto l'intestazione

Codice:
// LISTADI1.H : Implementazione dinamica della struttura astratta lista
// realizzata con libreria di funzioni. File di SPECIFICA

#ifndef _LISTA_H_ // Compilazione condizionale
#define _LISTA_H_


typedef int E; // Def. del tipo di el. della lista
struct Record; // Predichiarazione
typedef Record* L; // Def. del tipo puntatore a Record
struct Record { // Tipo record costituito da
E elem; // campo informazione
L punt; // campo puntatore al prossimo nodo della lista
};

void start(L& l); // Inizializza la lista
bool empty(const L& l); // Test di lista vuota
bool full(const L& l); // Test di lista piena
void insert(L& l, const E & e); // Inserimento in coda
bool erase(L& l, const E & e);    // Cancellazione di un elemento specificato
bool inlist(const L& l, const E & e); // Vera se e e' presente nella lista
void print(const L &l); // Stampa la lista
void clear(L & l);                      // Distrugge la lista

#endif


[/size]
Da qui capiamo che la struttura record ha 2 campi
-il contenuto (elem )
-puntatore (punt)

ed l di tipo L che è puntatore alla testa della lista


Poi vi metto l'implementazione

Codice:
// LISTA.CPP : Implementazione dinamica della struttura lista con
//   libreria di funzioni. File di IMPLEMENTAZIONE

#include "lista1.h"
#include <iostream>
using namespace std;

//------------------------------------------------------------
void start(L& l) {
l=0;
}
//------------------------------------------------------------
bool empty(const L& l) {
return (l==0);
}
//------------------------------------------------------------
bool full(const L& l) {
return false;
}
//------------------------------------------------------------
void push(L& l,const E & e) {
L q=new Record; //alloca spazio
q->elem=e; //vi pone e
q->punt=l; //lega al resto della lista
l=q; //lo mette in testa alla lista
}
//------------------------------------------------------------
// insert versione iterativa
void insert(L& l,const E & e) {
   if(l==0 || l->elem>e) push(l,e);  //l'elemento va inserito in testa
   else {                            //l'elemento va inserito al centro o in coda
      L prec=l, succ;                            
    //alloca ed inizializza il nuovo elemento
      L q=new Record;
      q->elem=e;
      q->punt=0;  
      while(prec->punt && prec->punt->elem<e ) prec=prec->punt; //determina prec
      succ=prec->punt; //determina succ, se l'inserimento è in coda succ deve valere 0
      // collega il nuovo elemento al resto della lista (anche in coda se è il caso)
      q->punt=succ;
      prec->punt=q;
}
//------------------------------------------------------------
void pop(L& l,E& e) {       //oppure: bool pop(L& l,E& e)
e=l->elem;   // copia in e il primo elemento
L p=l; // salva il valore di  l
l=l->punt; //aggiorna l
delete p; // dealloca il primo elemento
}
//------------------------------------------------------------
// lastpop versione iterativa
void lastpop(L& l,E& e) {      //oppure: bool lastpop(L& l,E& e)

   if(l->punt==0) pop(l,e);
   else     {
     L temp=l;
     while(temp->punt->punt) temp=temp->punt; //scorre la lista, si ferma sul penultimo elemento
     e=temp->punt->elem;  // copia in e l'ultimo elemento
     L p=temp->punt;     // salva l'indirizzo dell'ultimo elemento
     temp->punt=0;       // "stacca" l'ultimo elemento dalla lista
     delete p;          // dealloca l'ultimo elemento
  }
}
//------------------------------------------------------------
// inlist: ricerca sequenziale versione iterativa
bool inlist(const L& l,const E & e) {
    L temp=l;
    bool trovato=false;
while (temp && !trovato) {
      if (e==temp->elem) trovato=true;
      else
      temp=temp->punt;
    }
    return trovato;
}
//------------------------------------------------------------
// stampa versione iterativa
void print(const L & l) {
    L temp=l;
while(temp) {
 cout << temp->elem;
      cout <<  "\t";
      temp=temp->punt;
}
}
[/size]
Andiamo con ordine ragionando sull'operazione di push (inserimento in testa)
Codice:
//------------------------------------------------------------
void push(L& l,const E & e) {
L q=new Record; //alloca spazio
q->elem=e; //vi pone e
q->punt=l; //lega al resto della lista
l=q; //lo mette in testa alla lista
}
//------------------------------------------------------------
[/size]questa mi crea un record con puntatore q di tipo L. Accedo a questo record con q-> (che equivale a *q), ed in particolare accedo ai campi due record ponendovi "e"   "l" .
Poi assegno q ad l, in modo tale che il puntatore alla testa della lista punti al nuovo record creato



poi la funzione inserimento
Codice:
// insert versione iterativa
void insert(L& l,const E & e) {
   if(l==0 || l->elem>e) push(l,e);  //l'elemento va inserito in testa
   else {                            //l'elemento va inserito al centro o in coda
      L prec=l, succ;                            
    //alloca ed inizializza il nuovo elemento
      L q=new Record;
      q->elem=e;
      q->punt=0;  
      while(prec->punt && prec->punt->elem<e ) prec=prec->punt; //determina prec
      succ=prec->punt; //determina succ, se l'inserimento è in coda succ deve valere 0
      // collega il nuovo elemento al resto della lista (anche in coda se è il caso)
      q->punt=succ;
      prec->punt=q;
[/size]
qui non ci incomincio a capire.....
if (il puntatore alla testa della lista è =0 oppure il campo elemento acceduto dal puntatore alla testa della lista è >e valore presente nel  campo elemento  del record) fai push mettendo il record in testa.

else
considera il puntatore a record "prec" inizializzato a quello di testa, e un altro puntatore a record "succ"
crea nuovo record, puntato da q , ed assegna ai due campi del nuovo record  "e" e  "0".
while( prec accede a punt ,secondo campo del record, e prec accede a punt che accede ad elemento  del record successivo che sia < e ) cioè faccio scorrere prec, giusto?  assegna a prec il puntatore e a succ il puntatore acceduto con prec.



assegna al secondo campo acceduto da q (quella del nuovo record) "succ"
e al campo punt acceduto da prec assegna q.

queste non le ho capite.
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #1 inserita:: Maggio 28, 2012, 11:22:27 am »

aik, innanzitutto va chiarito che quel codice non è una semplice implementazione di una lista, ma presuppone anche un criterio di ordinamento crescente della lista stessa. Da qui, il codice particolare della insert.

Quindi, la insert verifica che la lista non sia vuota o che la testa sia maggiore dell'elemento che si sta per inserire. Se una di queste condizioni risulta vera, significa che il nuovo elemento sarà la nuova testa.
Se invece le condizioni sono false (lista già inizializzata o elemento maggiore in ordine crescente) allora la insert:
per prima cosa cerca il punto dove il nuovo elemento dovrà essere inserito
Codice:
while(prec->punt && prec->punt->elem<e ) prec=prec->punt; //determina prec

Codice:
succ=prec->punt; //determina succ, se l'inserimento è in coda succ deve valere 0
      // collega il nuovo elemento al resto della lista (anche in coda se è il caso)
      q->punt=succ;
       prec->punt=q;

Inserisce il nuovo elemento e per fare ciò ha necessità di memorizzare il nodo (in succ) che precedentemente era agganciato a prec.
Il nuovo elemento quindi sarà collegato a sinistra a prec mentre a destra a succ.
     


Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #2 inserita:: Maggio 28, 2012, 05:08:00 pm »

Come mi immagino prec e succ?

il primo è un puntatore che inizializzo alla testa della lista.
il secondo che ne faccio? come si muove?

il while () mi dice che : mentre il puntatore prec accede ai secondi campi dei record, e fino a che questi puntano ad un primo campo del record < del primo campo del nuovo record. concordi?

finchè avviene tutto ciò, " prec=prec->punt " cioè assegno a prec i secondi campi dei record che son diversi da zero

e con " succ=prec->punt " assegno a succ i secondi campi dei record.
E da qui nasce la domanda: come si differenziano i due puntatori prec e succ? dopo questa istruzione non sono uguali?


però poi le due ultime istruzioni :
-assegnano succ al secondo campo del record nuovo
-assegnano q al secondo campo del record nuovo
cmq non mi torna
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #3 inserita:: Maggio 28, 2012, 05:42:28 pm »

Credo che tu stia commettendo un errore di lettura del codice derivato probabilmente dal fatto che lo studio del C++ è agli inizi.

Per rispondere alle tue domande iniziali, quindi, prec è il nodo che viene usato per scorrere la lista, succ è solo una variabile temporanea che servirà nel momento dell'inserimento del nuovo nodo.

Ecco la sequenza del codice riscritta spezzando la parte di codice eseguita dal while

Codice:
 while(prec->punt && prec->punt->elem<e )
         prec=prec->punt; //determina prec

      succ=prec->punt; //determina succ, se l'inserimento è in coda succ deve valere 0
      // collega il nuovo elemento al resto della lista (anche in coda se è il caso)
      q->punt=succ;
      prec->punt=q;

Il che significa che l'assegnazione della variabile succ avviene soltanto dopo il ciclo while.
Le condizioni di controllo del ciclo while sono:

Codice:
prec->punt

che può essere riscritto come
prec->punt != 0

quindi che ci sia un nodo successivo alla lista e

Codice:
&& prec->punt->elem<e

che il numero sia minore di quello che si sta inserendo.

Arrivato a quel punto, succ deve essere inizializzato con il nodo che è attualmente successivo al nodo prec. Il che significa che sì, sono uguali, ma è normale che lo siano perché il tuo scopo è inserire un nuovo nodo fra due esistenti. Cosa che viene fatta in queste 2 assegnazioni successive

Codice:
q->punt=succ;
      prec->punt=q;

il nodo nuovo q punta alla parte della lista successiva, mentre a prec viene agganciato il nuovo nodo q.

Ti consiglio di studiare un po' di teoria sulle liste linkate prima di buttarti sull'analisi del codice altrui altrimenti rischi di far funzionare la cosa meccanicamente, ma non logicamente.


 

Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #4 inserita:: Maggio 28, 2012, 08:11:58 pm »

Grazie mille Hyde

Non riesco a capire cosa si mette nella variabile succ dopo il ciclo while c'è scritto "succ=prec->punt" vado a mettere nella variabile succ (che è puntatore al nodo, io lo chiamo struct) il secondo campo del nodo (punt)?


quello che trovo più difficile da capire è perchè se il nodo ha due campi non accedo ad elem, invece di accedere a punt. Il primo è elem, poi viene punt. Quale è il ragionamento di base.



ti posso dire che questo non è un esercizio: è direttamente la teoria. Il libro che ho è per chi è già addetto alla materia. Da c++ a UML. Se mi puoi consigliare qualche libro anche qualche slides o qualcosa'alltro su internet te ne sarei grato. Basta ch però sia facile e ben spiegato.
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #5 inserita:: Maggio 28, 2012, 10:12:44 pm »

Aik, il punto centrale è la teoria riguardante una lista linkata.
Ogni nodo di una lista linkata è costituito da 2 elementi: il dato memorizzato e un puntatore all'elemento successivo.
Usando il tuo codice, quindi punt è il puntatore al nodo successivo della lista, mentre elem è il dato.
Una lista linkata è quindi come una catena, dove ogni anello è unito sia al precedente che al successivo.
Immagina ora di voler inserire un nuovo anello nella catena.
Ti serve un riferimento al pezzo di catena a sinistra ed un riferimento al pezzo di catena di destra prima di poter inserire un nuovo anello nel mezzo.
Ecco quel codice fa proprio questo.
succ = prev->punt // memorizza la parte di catena alla destra
prev->punt = q //collega il nuovo anello alla parte di sinistra
q->punt = succ  // ricollega la parte di sinistra, con l'aggiunta del nuovo anello alla parte di destra

Sul fronte del materiale di studio ti consiglio di dare uno sguardo al thread "Come imparare c++"
Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #6 inserita:: Maggio 29, 2012, 07:14:06 pm »

allora

considero elementi 5 -10- 15- 20
e voglio inserire 12


in prec metto il puntatore all'elemento che contiene 5 (testa della lista)

Ora metre prec accede ai punt e e mentre accede a punt che accedono ai campi elem < 12 , fai accedere prec ai punt (cioè scorri la lista)

Arrivati a 12, si ricontrolla il while ed una condizione viene meno poichè 15<12 e quindi termina ciclo while e succ punta a 10.

In succ (che è una variabile puntatore) metto puntatore al successivo rispetto a quello che voglio inserire (succ lo faccio puntare a 15).


faccio in modo che l'elemento che voglio inserire abbia come punt, succ
|12 | succ|

faccio in modo che l'elem che viene puntato da prec (10) abbia come punt q
cioè |10|q|
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #7 inserita:: Maggio 29, 2012, 11:35:48 pm »

Esatto  Sorriso

Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #8 inserita:: Maggio 30, 2012, 03:48:00 pm »

grazie mille
sei stato di grande aiuto
Registrato
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #9 inserita:: Luglio 04, 2012, 02:53:50 pm »

ciao Hyde
potrei avere una manina su una parte di programma che prevede l'uso di una coda?
Questa coda deve permettere all'utente di inserire una transazione, eliminarla e stampare la sequenza di transazioni?

questa è l'intestazione e non ci son problemi

first è il puntatore alla coda
che viene posizionato alla testa della coda dal costruttore della classe CodaTransazioni
Codice:
#ifndef _CODATRANSAZIONI_H_
#define _CODATRANSAZIONI_H_
#include "Soggiorno.h"

struct Nodo
{
    Transazione*T;   //[B]il nodo composto da due campi: T e next[/B]
    Nodo*next;
};

class CodaTransazioni
{
      private:
              Nodo*first;
      public:
              CodaTransazioni(){first=0;}
              bool Empty(){return first==0;}
              bool Append(Transazione*);
              bool Pop();
              bool StampaCoda();
              bool MemorizzaTransazioni();
              ~CodaTransazioni();
};
#endif




1

Questa funzione inserisce una transazione nella coda
e mi dice che:

SE la coda è diversa da vuota allora
-crea un altro puntatore alla struttura Nodo e lo inizializza a first, in modo da puntare alla testa della coda.
-while (questo puntatore temp accede al campo next diverso da 0, quindi non elemento di fine coda) , fai accedere tempo ai prossimi campi next


-temp che accede al campo next ponilo come nuovo nodo??? (questa è strana)

-setta i campi di questo nuovo nodo con next =0  e  T=Tr dove Tr è il parametro passato alla funzione Append stessa
-poni vero in esito, cioè è avvenuto l'inserimento


questo insomma fa l'inserimento in cosa, giusto?


OPPURE

-crea nuovo nodo e mettilo in first
-setta i campi del nuovo nodo con tr e 0
-esito è positivo , poichè è avvenuto l'inserimento.

questo fa l'inserimento del primo elemento nella coda giusto?


Codice:
#include "CodaTransazioni.h"

bool CodaTransazioni::Append(Transazione*Tr)
{
    bool esito=false;
    if(!Empty())
    {
        Nodo*temp=first;
        while(temp->next!=0) temp=temp->next;
        temp->next=new Nodo;
        temp->next->next=0;
        temp->next->T=Tr;
        esito=true;
    }
    else
    {
        first=new Nodo;
        first->next=0;
        first->T=Tr;
        esito=true;
    }
    return esito;
}


2

SE la coda è diversa da vuota

-crea un puntatore a Nodo, e lo inizializza a first (testa della coda)

-mette in first, first che accede ai successivi elementi (questa è strana)

-cancella temp

io non ho capito a che serve instanziare temp




Codice:
bool CodaTransazioni::Pop()
{
    if(!Empty())
    {
        Nodo*temp=first;
        first=first->next;
        delete temp;
        return true;
    }
    else return false;
}






3

-crea sempre il solito puntatore temp a nodo, inizializzato alla testa della coda
-while (temp è diverso da 0, cioè non accede alla fine della coda , giusto?

questa non l'ho capita
Codice:
CodaTransazioni::~CodaTransazioni()
{
    Nodo*temp=first;
    while(temp!=0)
    {
        temp=first->next;
        delete first;
        first=temp;
    }
    first=0;
}


4

questa dovrebbe accedere tramite temp al campo T degli elementi della coda , e tramite T che è oggetto della classe Transazioni, richiamare la funzione stampaDati della classe transazioni.
Però non ho capito perchè dopo aver richiamato la funzione c'è una tal funzione
temp=temp->next;

Codice:
bool CodaTransazioni::StampaCoda()
{
    if(!Empty())
    {
        Nodo*temp=first;
        while(temp!=0)
        {
            temp->T->StampaDati();
            temp=temp->next;
        }
        return true;
    }
    else return false;
}

5

questa funzione secondo il testo dovrebbe essere una funziona che invocata su un oggetto di classe coda, scrive su file di tipo testo i dati relativi a tutte le transizioni in coda......questa me ne preoccuperei dopo


Codice:
bool CodaTransazioni::MemorizzaTransazioni()
{
    if(!Empty())
    {
        Nodo*temp=first;
        while(temp!=0)
        {
            temp->T->StampaSuFile();
            temp=temp->next;
        }
        return true;
    }
    else return false;
}


Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #10 inserita:: Luglio 04, 2012, 04:33:11 pm »

aik, poiché non posso dire al mio datore di lavoro di addebitarti il tempo che ho speso per capire il tuo post, ecco le mie risposte dopo una lettura veloce.

Punto 1: non ho capito la domanda

Punto 2:
Citazione
-mette in first, first che accede ai successivi elementi (questa è strana)

Non è affatto strana. Questa struttura rappresenta una PILA, ovvero una struttura di tipo FIFO (First In First Out), quindi il metodo pop deve cancellare il primo elemento nella lista
temp copia quello che è l'attuale primo elemento, quello cioè da cancellare ed è necessario altrimenti cancellando direttamente first perderesti i riferimenti al nodo successivo.
La cosa strana di quel codice è che una pop che cancella e basta, senza restituire al chiamante l'elemento non ha un senso logico, così a prima vista.

Punto 3:
Svuota tutta la lista. Anche qui è valido il ragionamento di prima: se cancelli direttamente l'elemento senza metterlo in una variabile temporanea perdi il riferimento al successivo..

Punto 4:
Citazione
Però non ho capito perchè dopo aver richiamato la funzione c'è una tal funzione
temp=temp->next;

Perché devi scorrere la lista. Appena entra nel while temp rappresenta l'inizio della lista, stampa quello che deve stampare poi passa al nodo successivo proprio con temp = temp->next. Si valuta la condizione del while, se è un elemento valido lo si stampa e si va avanti, altrimenti si esce.

Punto 5:
è uguale al punto 4, cambia soltanto il metodo richiamato.

Credo che l'argomento liste e puntatori debba essere ulteriolmente approfondito.
Hai dato un'occhiata al post che ti avevo suggerito nel mio ultimo intervento?
Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #11 inserita:: Luglio 06, 2012, 12:34:55 pm »

1
Per la prima , mi sembrava strano che ci fosse un'istruzione del genere temp->next=new Nodo;
poi se le due domande sottolineate erano giuste

2
Non ho capito se i soggetti che hai usato nelle frasi sono corretti:
Temp è un puntatore a nodo che è inizializzato a first, cioè punta allo stesso oggetto di first.

Perchè dici che Temp copia l'attuale 1° elemento? non è first che copia, visto che si va a memorizzare in first?

poi si cancella temp e non first

3

il punto3 è più chiaro dopo ciò che hai scritto per il punto 2, però qui mi trovo meglio che nel punto 2: p.e.  vado a memorizzare in temp, l'elemento puntato da first, memorizzando il riferimento al successivo.
e poi cancello first.
NEl punto 2 invece memorizzo in first l'elemento puntato da first, memorizzando il riferimento al successivo.
Però nel punto 2 vado a cancellare temp e non first.

4


credo che devo entrare nell'ottica, ma mi trovo con questa e allora pure con la 5

grazie mille
si ho approfondito, ho trovato anche qualche altro materiale su internet, ma  trovo diverso trattare un problema con  una pila,coda rispetto a quello che ho visto in "teoria"
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #12 inserita:: Luglio 06, 2012, 07:57:35 pm »

1)
COme fa a semrarti strano un'istruzione del tipo temp->next=new Nodo?
Questo è un inserimento di un nuovo elemento, quindi prima bisogna crearlo. Non pensare che siccome lo si crea su una variabile chiamata temp significhi che esso è temporaneo. In tutti gli spezzoni di codice che hai postato temp è sempre e comunque usato per scorrere la lista.
Le due affermazioni sono corrette.

2) Con la mia affermazione
Citazione
temp copia quello che è l'attuale primo elemento

intendevo dire che temp è una copia del primo elemento..

3)
Citazione
El punto 2 invece memorizzo in first l'elemento puntato da first, memorizzando il riferimento al successivo.
Però nel punto 2 vado a cancellare temp e non first.

Da questa affermazione è ancora più evidente che senza approfondire e capire l'argomento puntatori tutto ti sembrerà strano. Il termine puntatore, come suggerisce il termine, è una variabile che punta ad un indirizzo di memoria, quindi, se temp punta a first, di fatto, esso impersona first. Cancellando temp, quindi, cancelli ciò a cui temp punta, quindi first.


Citazione
ma  trovo diverso trattare un problema con  una pila,coda rispetto a quello che ho visto in "teoria"

A te servono 2 teorie: 1 sul linguaggio C e lì più che al materiale trovato su internet io mi affiderei ad un buon sano libro. L'altra è sugli algoritmi.. Ed anche qui generalmente un libro è preferibile.
Tu attualmente vuoi arrivare al risultato finale, ovvero capire il C e le code (algoritmi), saltando tutti i passaggi intermedi e questo non è cosa buona.
Non approfittare delle persone che frequentano un forum, perché esse non sono mai surrogati della teoria.
Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
aik
Newbie
*

Karma: +0/-0
Scollegato Scollegato

Messaggi: 16


Mostra profilo E-mail
« Risposta #13 inserita:: Luglio 08, 2012, 06:29:10 pm »

Ciao Hyde, ti ringrazio moltissimo del tuo aiuto
però non volevo approfittare di te, e soprattutto il termine mi sembra esagerato ed aggressivo visto che c'è per mezzo un forum. Eventualmente avresti potuto dire : "non chiedere un chiarimento a persone che ne capiscono più  di te". Questo forse è più giusto.

Non volevo saltare nulla,  però la teoria che ho a disposizione l'ho vista e non mi aiuta a ragionare su questi problemi, e soprattutto non riesco a capire alcune cose, viste che non sono presenti in teoria; però me ne sono fatto quasi una ragione poichè qui da me è sempre tutto così: spiegano 10 e danno libri da 10 (generalmente per persone già competenti) e vogliono 100; però per questo esame sono andato oltre ricercando su internet diverse teorie

Alcuni comandi li ho capiti:
Nodo *temp=new Nodo;  come la creazione di un nuovo nodo e la sua inizializzazione.
temp->T=Tr;
temp->next=0;

o con questi altri

temp->next->T=Tr;
temp->next-<next=0;

Lo scorere degli elementi tipo temp->next!=0  o temp= temp->next;  vanno bene
però poi se compaiono così senza la logicità che trovo in queste funzioni non le capisco..

ti rinnovo i ringraziamenti grazie infinite ancora
buon resto di domenica
Registrato
Hyde
Global Moderator
Hero Member
*****

Karma: +47/-7
Scollegato Scollegato

Messaggi: 3266


I am a man who walks alone


Mostra profilo WWW
« Risposta #14 inserita:: Luglio 09, 2012, 11:47:12 pm »

aik, i moderatori sono qui anche per fare qualche rimprovero, quando necessario, quindi prendilo come un modo per spronarti nello studio!
Registrato

I Moderatori invitano tutti gli utenti a prendere visione del REGOLAMENTO e a rispettarlo.
http://myitside.blogspot.com
Pagine: [1]   Vai su
  Stampa  
 
Vai a:  

Copyright © 2011 Edizioni Master SpA. p.iva : 02105820787

Tutti i diritti di proprietà letteraria e artistica riservati. - Privacy



Links to Page